fix: golangci-lint and gosec warnings

This commit is contained in:
Markus Pesch 2021-05-16 23:02:46 +02:00
parent a745311b7b
commit bd3e9ff43d
Signed by: volker.raschek
GPG Key ID: 852BCC170D81A982
19 changed files with 204 additions and 155 deletions

29
.golangci.yml Normal file
View File

@ -0,0 +1,29 @@
run:
skip-dirs:
- it
timeout: 10m
tests: true
linters:
disable-all: true
enable:
# Default
- deadcode
- errcheck
- gosimple
- govet
- ineffassign
- staticcheck
- structcheck
- typecheck
- unused
- varcheck
# Additionally linters
- bodyclose
- misspell
- nilerr
- rowserrcheck
- sqlclosecheck
- unparam
- whitespace

View File

@ -103,6 +103,18 @@ PHONY+=test/coverage
test/coverage: test/unit test/coverage: test/unit
go tool cover -html=coverage.txt go tool cover -html=coverage.txt
# GOLANGCI-LINT
# ==============================================================================
PHONY+=golangci-lint
golangci-lint:
golangci-lint run --concurrency=$(shell nproc)
# GOSEC
# ==============================================================================
PHONY+=gosec
gosec:
gosec $(shell pwd)/...
# PHONY # PHONY
# ============================================================================== # ==============================================================================
# Declare the contents of the PHONY variable as phony. We keep that information # Declare the contents of the PHONY variable as phony. We keep that information

View File

@ -11,15 +11,7 @@ import (
"github.com/spf13/cobra" "github.com/spf13/cobra"
) )
var (
importSensors bool
importHumidities bool
importPressures bool
importTemperatures bool
)
func InitCmd(cmd *cobra.Command) error { func InitCmd(cmd *cobra.Command) error {
importCmd := &cobra.Command{ importCmd := &cobra.Command{
Use: "import", Use: "import",
Args: cobra.RangeArgs(1, 2), Args: cobra.RangeArgs(1, 2),
@ -34,7 +26,6 @@ import sqlite3:///var/cache/flucky/sqlite3.db postgres://user:password@host:port
} }
func importSources(cmd *cobra.Command, args []string) error { func importSources(cmd *cobra.Command, args []string) error {
configFile, err := cmd.Flags().GetString("config") configFile, err := cmd.Flags().GetString("config")
if err != nil { if err != nil {
return fmt.Errorf("No config file defined") return fmt.Errorf("No config file defined")

View File

@ -21,7 +21,6 @@ import (
// Execute a // Execute a
func Execute(version string) error { func Execute(version string) error {
rootCmd := &cobra.Command{ rootCmd := &cobra.Command{
Use: "flucky", Use: "flucky",
PersistentPreRunE: preRunError, PersistentPreRunE: preRunError,
@ -59,13 +58,11 @@ func Execute(version string) error {
} }
func preRunError(cmd *cobra.Command, args []string) error { func preRunError(cmd *cobra.Command, args []string) error {
configFile := cmd.Flag("config").Value.String() configFile := cmd.Flag("config").Value.String()
// check if config file exists // check if config file exists
if _, err := os.Stat(configFile); os.IsNotExist(err) { if _, err := os.Stat(configFile); os.IsNotExist(err) {
// Time must be truncated for postgres. Postgres currently does not support
// Time must be truncted for postgres. Postgres currently does not support
// nanoseconds which is automatically include into the go time object // nanoseconds which is automatically include into the go time object
postgresTimeStamp := time.Now() postgresTimeStamp := time.Now()
location, err := time.LoadLocation("Europe/Berlin") location, err := time.LoadLocation("Europe/Berlin")

View File

@ -98,7 +98,6 @@ flucky sensor rename f98b00ea-a9b2-4e00-924f-113859d0af2d outdoor`,
} }
func addSensor(cmd *cobra.Command, args []string) error { func addSensor(cmd *cobra.Command, args []string) error {
sensor := &types.Sensor{ sensor := &types.Sensor{
ID: uuid.NewV4().String(), ID: uuid.NewV4().String(),
Name: args[0], Name: args[0],
@ -200,7 +199,6 @@ func addSensor(cmd *cobra.Command, args []string) error {
} }
func disableSensor(cmd *cobra.Command, args []string) error { func disableSensor(cmd *cobra.Command, args []string) error {
configFile, err := cmd.Flags().GetString("config") configFile, err := cmd.Flags().GetString("config")
if err != nil { if err != nil {
return fmt.Errorf("No config file defined") return fmt.Errorf("No config file defined")
@ -246,7 +244,6 @@ func disableSensor(cmd *cobra.Command, args []string) error {
} }
func enableSensor(cmd *cobra.Command, args []string) error { func enableSensor(cmd *cobra.Command, args []string) error {
configFile, err := cmd.Flags().GetString("config") configFile, err := cmd.Flags().GetString("config")
if err != nil { if err != nil {
return fmt.Errorf("No config file defined") return fmt.Errorf("No config file defined")
@ -292,7 +289,6 @@ func enableSensor(cmd *cobra.Command, args []string) error {
} }
func listSensors(cmd *cobra.Command, args []string) error { func listSensors(cmd *cobra.Command, args []string) error {
configFile, err := cmd.Flags().GetString("config") configFile, err := cmd.Flags().GetString("config")
if err != nil { if err != nil {
return fmt.Errorf("No config file defined") return fmt.Errorf("No config file defined")
@ -335,7 +331,6 @@ func listSensors(cmd *cobra.Command, args []string) error {
} }
func removeSensor(cmd *cobra.Command, args []string) error { func removeSensor(cmd *cobra.Command, args []string) error {
configFile, err := cmd.Flags().GetString("config") configFile, err := cmd.Flags().GetString("config")
if err != nil { if err != nil {
return fmt.Errorf("No config file defined") return fmt.Errorf("No config file defined")
@ -367,7 +362,6 @@ func removeSensor(cmd *cobra.Command, args []string) error {
} }
func renameSensor(cmd *cobra.Command, args []string) error { func renameSensor(cmd *cobra.Command, args []string) error {
configFile, err := cmd.Flags().GetString("config") configFile, err := cmd.Flags().GetString("config")
if err != nil { if err != nil {
return fmt.Errorf("No config file defined") return fmt.Errorf("No config file defined")
@ -410,5 +404,4 @@ func renameSensor(cmd *cobra.Command, args []string) error {
} }
return nil return nil
} }

View File

@ -97,26 +97,22 @@ func readTemperature(cmd *cobra.Command, args []string) error {
go func() { go func() {
for { for {
select { err, open := <-errorChannel
case err, open := <-errorChannel: if !open {
if !open { return
return
}
flogger.Error("%v", err)
} }
flogger.Error("%v", err)
} }
}() }()
measuredValues := make([]*types.MeasuredValue, 0) measuredValues := make([]*types.MeasuredValue, 0)
LOOP: LOOP:
for { for {
select { measuredValue, open := <-measuredValueChannel
case measuredValue, open := <-measuredValueChannel: if !open {
if !open { break LOOP
break LOOP
}
measuredValues = append(measuredValues, measuredValue)
} }
measuredValues = append(measuredValues, measuredValue)
} }
err = cli.PrintMeasuredValues(measuredValues, os.Stdout) err = cli.PrintMeasuredValues(measuredValues, os.Stdout)

View File

@ -1,6 +1,8 @@
package main package main
import ( import (
"log"
"git.cryptic.systems/volker.raschek/flucky/cli" "git.cryptic.systems/volker.raschek/flucky/cli"
_ "github.com/golang-migrate/migrate/v4/database/postgres" _ "github.com/golang-migrate/migrate/v4/database/postgres"
@ -14,5 +16,8 @@ var (
) )
func main() { func main() {
cli.Execute(version) err := cli.Execute(version)
if err != nil {
log.Println(err)
}
} }

View File

@ -9,7 +9,6 @@ import (
) )
func PrintMeasuredValues(measuredValues []*types.MeasuredValue, w io.Writer) error { func PrintMeasuredValues(measuredValues []*types.MeasuredValue, w io.Writer) error {
// declar tabwriter // declar tabwriter
tw := tabwriter.NewWriter(w, 0, 0, 3, ' ', 0) tw := tabwriter.NewWriter(w, 0, 0, 3, ' ', 0)
@ -29,7 +28,6 @@ func PrintMeasuredValues(measuredValues []*types.MeasuredValue, w io.Writer) err
// PrintSensors displays a list with all configured sensors // PrintSensors displays a list with all configured sensors
func PrintSensors(sensors []*types.Sensor, w io.Writer) error { func PrintSensors(sensors []*types.Sensor, w io.Writer) error {
// declar tabwriter // declar tabwriter
tw := tabwriter.NewWriter(w, 0, 0, 3, ' ', 0) tw := tabwriter.NewWriter(w, 0, 0, 3, ' ', 0)

View File

@ -31,20 +31,21 @@ func Encode(cnf *Config, w io.Writer) error {
// Read the configuration file // Read the configuration file
func Read(configFile string) (*Config, error) { func Read(configFile string) (*Config, error) {
/* #nosec */
f, err := os.Open(configFile) f, err := os.Open(configFile)
if err != nil { if err != nil {
return nil, fmt.Errorf("Can not open file %v: %v", configFile, err) return nil, fmt.Errorf("Can not open file %v: %v", configFile, err)
} }
defer f.Close() defer func() { _ = f.Close() }()
return Decode(f) return Decode(f)
} }
// Write the configuration into a file, specified by the configuration filepath // Write the configuration into a file, specified by the configuration filepath
func Write(cnf *Config, configFile string) error { func Write(cnf *Config, configFile string) error {
if _, err := os.Stat(configFile); os.IsNotExist(err) { if _, err := os.Stat(configFile); os.IsNotExist(err) {
configDir := filepath.Dir(configFile) configDir := filepath.Dir(configFile)
/* #nosec */
err := os.MkdirAll(configDir, 0775) err := os.MkdirAll(configDir, 0775)
if err != nil { if err != nil {
return fmt.Errorf("Failed to create config directory %v: %v", configDir, err) return fmt.Errorf("Failed to create config directory %v: %v", configDir, err)
@ -55,7 +56,7 @@ func Write(cnf *Config, configFile string) error {
if err != nil { if err != nil {
return fmt.Errorf("Failed not create config file %v: %v", configFile, err) return fmt.Errorf("Failed not create config file %v: %v", configFile, err)
} }
defer f.Close() defer func() { _ = f.Close() }()
return Encode(cnf, f) return Encode(cnf, f)
} }

View File

@ -6,6 +6,7 @@ import (
"net/url" "net/url"
"os" "os"
"os/signal" "os/signal"
"syscall"
"git.cryptic.systems/volker.raschek/flucky/pkg/config" "git.cryptic.systems/volker.raschek/flucky/pkg/config"
"git.cryptic.systems/volker.raschek/flucky/pkg/repository" "git.cryptic.systems/volker.raschek/flucky/pkg/repository"
@ -15,7 +16,6 @@ import (
) )
func Start(cnf *config.Config, cachedEntries uint, flogger logger.Logger) error { func Start(cnf *config.Config, cachedEntries uint, flogger logger.Logger) error {
// load data source name (dsn) // load data source name (dsn)
dsnURL, err := url.Parse(cnf.DSN) dsnURL, err := url.Parse(cnf.DSN)
if err != nil { if err != nil {
@ -79,7 +79,7 @@ func Start(cnf *config.Config, cachedEntries uint, flogger logger.Logger) error
} }
interruptChannel := make(chan os.Signal, 1) interruptChannel := make(chan os.Signal, 1)
signal.Notify(interruptChannel, os.Interrupt, os.Kill) signal.Notify(interruptChannel, syscall.SIGTERM)
// Collection // Collection
parentCtx := context.Background() parentCtx := context.Background()

View File

@ -1,14 +1,11 @@
package format package format
import ( import (
"errors"
"math" "math"
"time" "time"
) )
var ( var (
errorPraseTime = errors.New("Can not parse time")
TimeFormat = "2006-01-02T15:04:05.999999Z07:00" TimeFormat = "2006-01-02T15:04:05.999999Z07:00"
) )
@ -19,5 +16,4 @@ func FormatedTime() time.Time {
t := time.Now() t := time.Now()
l, _ := time.LoadLocation("Europe/Berlin") l, _ := time.LoadLocation("Europe/Berlin")
return time.Date(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), int(math.Round(float64(t.Nanosecond())/1000000)*1000000), l) return time.Date(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), int(math.Round(float64(t.Nanosecond())/1000000)*1000000), l)
} }

View File

@ -67,7 +67,7 @@ func (d *Postgres) AddDevices(ctx context.Context, devices ...*types.Device) err
if err != nil { if err != nil {
return fmt.Errorf("Failed to begin new transaction: %v", err) return fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
err = d.insertDevices(tx, devices...) err = d.insertDevices(tx, devices...)
if err != nil { if err != nil {
@ -82,10 +82,9 @@ func (d *Postgres) insertDevices(tx *sql.Tx, devices ...*types.Device) error {
if err != nil { if err != nil {
return fmt.Errorf("Failed to prepare statement: %v", err) return fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, device := range devices { for _, device := range devices {
if device.CreationDate.Equal(time.Time{}) { if device.CreationDate.Equal(time.Time{}) {
device.CreationDate = time.Now() device.CreationDate = time.Now()
} }
@ -110,7 +109,7 @@ func (d *Postgres) AddOrUpdateDevices(ctx context.Context, devices ...*types.Dev
if err != nil { if err != nil {
return fmt.Errorf("Failed to begin new transaction: %v", err) return fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
err = d.insertOrUpdateDevices(tx, devices...) err = d.insertOrUpdateDevices(tx, devices...)
if err != nil { if err != nil {
@ -125,10 +124,9 @@ func (d *Postgres) insertOrUpdateDevices(tx *sql.Tx, devices ...*types.Device) e
if err != nil { if err != nil {
return fmt.Errorf("Failed to prepare statement: %w", err) return fmt.Errorf("Failed to prepare statement: %w", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, device := range devices { for _, device := range devices {
if device.CreationDate.Equal(time.Time{}) { if device.CreationDate.Equal(time.Time{}) {
device.CreationDate = time.Now() device.CreationDate = time.Now()
} }
@ -163,7 +161,7 @@ func (d *Postgres) AddMeasuredValues(ctx context.Context, measuredValues ...*typ
if err != nil { if err != nil {
return fmt.Errorf("Failed to begin new transaction: %v", err) return fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
for measuredValueType, measuredValues := range splittedMeasuredValues { for measuredValueType, measuredValues := range splittedMeasuredValues {
var queryFile string var queryFile string
@ -193,10 +191,9 @@ func (d *Postgres) insertMeasuredValues(tx *sql.Tx, query string, measuredValues
if err != nil { if err != nil {
return fmt.Errorf("Failed to prepare statement: %v", err) return fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, measuredValue := range measuredValues { for _, measuredValue := range measuredValues {
if measuredValue.CreationDate.Equal(time.Time{}) { if measuredValue.CreationDate.Equal(time.Time{}) {
measuredValue.CreationDate = time.Now() measuredValue.CreationDate = time.Now()
} }
@ -233,7 +230,7 @@ func (d *Postgres) AddOrUpdateMeasuredValues(ctx context.Context, measuredValues
if err != nil { if err != nil {
return fmt.Errorf("Failed to begin new transaction: %v", err) return fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
for measuredValueType, measuredValues := range splittedMeasuredValues { for measuredValueType, measuredValues := range splittedMeasuredValues {
var queryFile string var queryFile string
@ -263,10 +260,9 @@ func (d *Postgres) insertOrUpdateMeasuredValues(tx *sql.Tx, query string, measur
if err != nil { if err != nil {
return fmt.Errorf("Failed to prepare statement: %v", err) return fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, measuredValue := range measuredValues { for _, measuredValue := range measuredValues {
if measuredValue.CreationDate.Equal(time.Time{}) { if measuredValue.CreationDate.Equal(time.Time{}) {
measuredValue.CreationDate = time.Now() measuredValue.CreationDate = time.Now()
} }
@ -294,16 +290,15 @@ func (d *Postgres) AddSensors(ctx context.Context, sensors ...*types.Sensor) err
if err != nil { if err != nil {
return fmt.Errorf("Failed to begin new transaction: %v", err) return fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
stmt, err := tx.Prepare(postgres.InsertSensorSQL) stmt, err := tx.Prepare(postgres.InsertSensorSQL)
if err != nil { if err != nil {
return fmt.Errorf("Failed to prepare statement: %v", err) return fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, sensor := range sensors { for _, sensor := range sensors {
if sensor.CreationDate.Equal(time.Time{}) { if sensor.CreationDate.Equal(time.Time{}) {
sensor.CreationDate = time.Now() sensor.CreationDate = time.Now()
} }
@ -337,7 +332,7 @@ func (d *Postgres) AddOrUpdateSensors(ctx context.Context, sensors ...*types.Sen
if err != nil { if err != nil {
return fmt.Errorf("Failed to begin new transaction: %v", err) return fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
err = d.insertOrUpdateSensors(tx, sensors...) err = d.insertOrUpdateSensors(tx, sensors...)
if err != nil { if err != nil {
@ -352,10 +347,9 @@ func (d *Postgres) insertOrUpdateSensors(tx *sql.Tx, sensors ...*types.Sensor) e
if err != nil { if err != nil {
return fmt.Errorf("Failed to prepare statement: %v", err) return fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, sensor := range sensors { for _, sensor := range sensors {
if sensor.CreationDate.Equal(time.Time{}) { if sensor.CreationDate.Equal(time.Time{}) {
sensor.CreationDate = time.Now() sensor.CreationDate = time.Now()
} }
@ -416,7 +410,7 @@ func (d *Postgres) GetDeviceByID(ctx context.Context, id string) (*types.Device,
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to begin new transaction: %v", err) return nil, fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
devices, err := d.selectDevices(tx, postgres.SelectDeviceByIDSQL, id) devices, err := d.selectDevices(tx, postgres.SelectDeviceByIDSQL, id)
if err != nil { if err != nil {
@ -441,7 +435,7 @@ func (d *Postgres) GetDeviceByName(ctx context.Context, name string) (*types.Dev
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to begin new transaction: %v", err) return nil, fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
devices, err := d.selectDevices(tx, postgres.SelectDeviceByNameSQL, name) devices, err := d.selectDevices(tx, postgres.SelectDeviceByNameSQL, name)
if err != nil { if err != nil {
@ -466,7 +460,7 @@ func (d *Postgres) GetDevices(ctx context.Context) ([]*types.Device, error) {
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to begin new transaction: %v", err) return nil, fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
devices, err := d.selectDevices(tx, postgres.SelectDevicesSQL) devices, err := d.selectDevices(tx, postgres.SelectDevicesSQL)
if err != nil { if err != nil {
@ -486,12 +480,13 @@ func (d *Postgres) selectDevices(tx *sql.Tx, query string, args ...interface{})
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to prepare statement: %v", err) return nil, fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
rows, err := stmt.Query(args...) rows, err := stmt.Query(args...)
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to query statement: %v", err) return nil, fmt.Errorf("Failed to query statement: %v", err)
} }
defer func() { _ = rows.Close() }()
devices := make([]*types.Device, 0) devices := make([]*types.Device, 0)
for rows.Next() { for rows.Next() {
@ -509,6 +504,10 @@ func (d *Postgres) selectDevices(tx *sql.Tx, query string, args ...interface{})
devices = append(devices, device) devices = append(devices, device)
} }
if err := rows.Err(); err != nil {
return nil, fmt.Errorf("failed to scan rows: %v", err)
}
return devices, nil return devices, nil
} }
@ -518,7 +517,7 @@ func (d *Postgres) GetHumidityByID(ctx context.Context, id string) (*types.Measu
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
measuredValues, err := d.selectMeasuredValue(tx, postgres.SelectHumidityByIDSQL, id) measuredValues, err := d.selectMeasuredValue(tx, postgres.SelectHumidityByIDSQL, id)
if err != nil { if err != nil {
@ -547,7 +546,7 @@ func (d *Postgres) GetHumidities(ctx context.Context) ([]*types.MeasuredValue, e
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
measuredValues, err := d.selectMeasuredValue(tx, postgres.SelectHumiditiesSQL) measuredValues, err := d.selectMeasuredValue(tx, postgres.SelectHumiditiesSQL)
if err != nil { if err != nil {
@ -571,16 +570,18 @@ func (d *Postgres) selectMeasuredValue(tx *sql.Tx, query string, args ...interfa
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
rows, err := stmt.Query(args...) rows, err := stmt.Query(args...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer func() { _ = rows.Close() }()
measuredValues := make([]*types.MeasuredValue, 0) measuredValues := make([]*types.MeasuredValue, 0)
for rows.Next() { for rows.Next() {
measuredValue := new(types.MeasuredValue) measuredValue := new(types.MeasuredValue)
err := rows.Scan( err := rows.Scan(
&measuredValue.ID, &measuredValue.ID,
&measuredValue.Value, &measuredValue.Value,
@ -589,14 +590,17 @@ func (d *Postgres) selectMeasuredValue(tx *sql.Tx, query string, args ...interfa
&measuredValue.CreationDate, &measuredValue.CreationDate,
&measuredValue.UpdateDate, &measuredValue.UpdateDate,
) )
if err != nil { if err != nil {
return nil, err return nil, fmt.Errorf("failed to scan row: %v", err)
} }
measuredValues = append(measuredValues, measuredValue) measuredValues = append(measuredValues, measuredValue)
} }
if err := rows.Err(); err != nil {
return nil, fmt.Errorf("failed to scan rows: %v", err)
}
return measuredValues, nil return measuredValues, nil
} }
@ -606,7 +610,7 @@ func (d *Postgres) GetPressureByID(ctx context.Context, id string) (*types.Measu
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
measuredValues, err := d.selectMeasuredValue(tx, postgres.SelectPressureByIDSQL, id) measuredValues, err := d.selectMeasuredValue(tx, postgres.SelectPressureByIDSQL, id)
if err != nil { if err != nil {
@ -635,7 +639,7 @@ func (d *Postgres) GetPressures(ctx context.Context) ([]*types.MeasuredValue, er
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
measuredValues, err := d.selectMeasuredValue(tx, postgres.SelectPressuresSQL) measuredValues, err := d.selectMeasuredValue(tx, postgres.SelectPressuresSQL)
if err != nil { if err != nil {
@ -660,7 +664,7 @@ func (d *Postgres) GetSensorByID(ctx context.Context, id string) (*types.Sensor,
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to begin new transaction: %v", err) return nil, fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
sensors, err := d.selectSensors(tx, postgres.SelectSensorByIDSQL, id) sensors, err := d.selectSensors(tx, postgres.SelectSensorByIDSQL, id)
if err != nil { if err != nil {
@ -685,7 +689,7 @@ func (d *Postgres) GetSensors(ctx context.Context) ([]*types.Sensor, error) {
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to begin new transaction: %v", err) return nil, fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
sensors, err := d.selectSensors(tx, postgres.SelectSensorsSQL) sensors, err := d.selectSensors(tx, postgres.SelectSensorsSQL)
if err != nil { if err != nil {
@ -706,7 +710,7 @@ func (d *Postgres) GetSensorsByDeviceIDs(ctx context.Context, deviceIDs ...strin
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to begin new transaction: %v", err) return nil, fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
cachedSensors := make([]*types.Sensor, 0) cachedSensors := make([]*types.Sensor, 0)
for i := range deviceIDs { for i := range deviceIDs {
@ -732,6 +736,7 @@ func (d *Postgres) GetSensorsByModels(ctx context.Context, sensorModels ...strin
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to begin new transaction: %v", err) return nil, fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer func() { _ = tx.Rollback() }()
cachedSensors := make([]*types.Sensor, 0) cachedSensors := make([]*types.Sensor, 0)
for i := range sensorModels { for i := range sensorModels {
@ -757,7 +762,7 @@ func (d *Postgres) GetSensorsByNames(ctx context.Context, sensorNames ...string)
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to begin new transaction: %v", err) return nil, fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
cachedSensors := make([]*types.Sensor, 0) cachedSensors := make([]*types.Sensor, 0)
for i := range sensorNames { for i := range sensorNames {
@ -782,12 +787,13 @@ func (d *Postgres) selectSensors(tx *sql.Tx, query string, args ...interface{})
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to prepare statement: %v", err) return nil, fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
rows, err := stmt.Query(args...) rows, err := stmt.Query(args...)
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to query statement: %v", err) return nil, fmt.Errorf("Failed to query statement: %v", err)
} }
defer func() { _ = rows.Close() }()
sensors := make([]*types.Sensor, 0) sensors := make([]*types.Sensor, 0)
for rows.Next() { for rows.Next() {
@ -814,6 +820,10 @@ func (d *Postgres) selectSensors(tx *sql.Tx, query string, args ...interface{})
sensors = append(sensors, sensor) sensors = append(sensors, sensor)
} }
if err := rows.Err(); err != nil {
return nil, fmt.Errorf("failed to scan rows: %v", err)
}
return sensors, nil return sensors, nil
} }
@ -823,7 +833,7 @@ func (d *Postgres) GetTemperatureByID(ctx context.Context, id string) (*types.Me
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
measuredValues, err := d.selectMeasuredValue(tx, postgres.SelectTemperatureByIDSQL, id) measuredValues, err := d.selectMeasuredValue(tx, postgres.SelectTemperatureByIDSQL, id)
if err != nil { if err != nil {
@ -852,7 +862,7 @@ func (d *Postgres) GetTemperatures(ctx context.Context) ([]*types.MeasuredValue,
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
measuredValues, err := d.selectMeasuredValue(tx, postgres.SelectTemperaturesSQL) measuredValues, err := d.selectMeasuredValue(tx, postgres.SelectTemperaturesSQL)
if err != nil { if err != nil {
@ -878,7 +888,7 @@ func (d *Postgres) Import(ctx context.Context, src Repository) error {
if err != nil { if err != nil {
return err return err
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
devices, err := src.GetDevices(ctx) devices, err := src.GetDevices(ctx)
if err != nil { if err != nil {
@ -928,13 +938,13 @@ func (d *Postgres) RemoveDevicesByIDs(ctx context.Context, deviceIDs ...string)
if err != nil { if err != nil {
return fmt.Errorf("Failed to begin new transaction: %v", err) return fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
stmt, err := tx.Prepare(postgres.DeleteDeviceByIDSQL) stmt, err := tx.Prepare(postgres.DeleteDeviceByIDSQL)
if err != nil { if err != nil {
return fmt.Errorf("Failed to prepare statement: %v", err) return fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, deviceID := range deviceIDs { for _, deviceID := range deviceIDs {
_, err = stmt.Exec(deviceID) _, err = stmt.Exec(deviceID)
@ -952,13 +962,13 @@ func (d *Postgres) RemoveDevicesByNames(ctx context.Context, names ...string) er
if err != nil { if err != nil {
return fmt.Errorf("Failed to begin new transaction: %v", err) return fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
stmt, err := tx.Prepare(postgres.DeleteDeviceByNameSQL) stmt, err := tx.Prepare(postgres.DeleteDeviceByNameSQL)
if err != nil { if err != nil {
return fmt.Errorf("Failed to prepare statement: %v", err) return fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, deviceID := range names { for _, deviceID := range names {
_, err = stmt.Exec(deviceID) _, err = stmt.Exec(deviceID)
@ -976,13 +986,13 @@ func (d *Postgres) RemoveSensorsByIDs(ctx context.Context, sensorIDs ...string)
if err != nil { if err != nil {
return fmt.Errorf("Failed to begin new transaction: %v", err) return fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
stmt, err := tx.Prepare(postgres.DeleteSensorByIDSQL) stmt, err := tx.Prepare(postgres.DeleteSensorByIDSQL)
if err != nil { if err != nil {
return fmt.Errorf("Failed to prepare statement: %v", err) return fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, sensorID := range sensorIDs { for _, sensorID := range sensorIDs {
_, err = stmt.Exec(sensorID) _, err = stmt.Exec(sensorID)
@ -1000,13 +1010,13 @@ func (d *Postgres) RemoveSensorsByNames(ctx context.Context, sensorIDs ...string
if err != nil { if err != nil {
return fmt.Errorf("Failed to begin new transaction: %v", err) return fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
stmt, err := tx.Prepare(postgres.DeleteSensorByNameSQL) stmt, err := tx.Prepare(postgres.DeleteSensorByNameSQL)
if err != nil { if err != nil {
return fmt.Errorf("Failed to prepare statement: %v", err) return fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, sensorID := range sensorIDs { for _, sensorID := range sensorIDs {
_, err = stmt.Exec(sensorID) _, err = stmt.Exec(sensorID)
@ -1024,13 +1034,13 @@ func (d *Postgres) UpdateDevices(ctx context.Context, devices ...*types.Device)
if err != nil { if err != nil {
return err return err
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
stmt, err := tx.Prepare(postgres.UpdateDeviceSQL) stmt, err := tx.Prepare(postgres.UpdateDeviceSQL)
if err != nil { if err != nil {
return err return err
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, device := range devices { for _, device := range devices {
now := time.Now() now := time.Now()
@ -1057,13 +1067,13 @@ func (d *Postgres) UpdateSensors(ctx context.Context, sensors ...*types.Sensor)
if err != nil { if err != nil {
return err return err
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
stmt, err := tx.Prepare(postgres.UpdateSensorSQL) stmt, err := tx.Prepare(postgres.UpdateSensorSQL)
if err != nil { if err != nil {
return err return err
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, sensor := range sensors { for _, sensor := range sensors {
now := time.Now() now := time.Now()

View File

@ -47,6 +47,7 @@ func NewSQLite(opts SQLiteOpts) (Repository, error) {
// Create directory if not exist // Create directory if not exist
if _, err := os.Stat(filepath.Dir(opts.DatabaseURL.Path)); os.IsNotExist(err) { if _, err := os.Stat(filepath.Dir(opts.DatabaseURL.Path)); os.IsNotExist(err) {
/* #nosec */
err := os.MkdirAll(filepath.Dir(opts.DatabaseURL.Path), 0755) err := os.MkdirAll(filepath.Dir(opts.DatabaseURL.Path), 0755)
if err != nil { if err != nil {
return nil, err return nil, err
@ -89,7 +90,7 @@ func (d *SQLite) AddDevices(ctx context.Context, devices ...*types.Device) error
if err != nil { if err != nil {
return fmt.Errorf("Failed to begin new transaction: %v", err) return fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
err = d.insertDevices(tx, devices...) err = d.insertDevices(tx, devices...)
if err != nil { if err != nil {
@ -104,10 +105,16 @@ func (d *SQLite) insertDevices(tx *sql.Tx, devices ...*types.Device) error {
if err != nil { if err != nil {
return fmt.Errorf("Failed to prepare statement: %v", err) return fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, device := range devices { for _, device := range devices {
_, err = stmt.Exec(&device.ID, &device.Name, &device.Location, &device.CreationDate, &device.UpdateDate) _, err = stmt.Exec(
&device.ID,
&device.Name,
&device.Location,
&device.CreationDate,
&device.UpdateDate,
)
if err != nil { if err != nil {
return fmt.Errorf("Failed to execute statement: %v", err) return fmt.Errorf("Failed to execute statement: %v", err)
} }
@ -125,7 +132,7 @@ func (d *SQLite) AddOrUpdateDevices(ctx context.Context, devices ...*types.Devic
if err != nil { if err != nil {
return fmt.Errorf("Failed to begin new transaction: %v", err) return fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
err = d.insertOrUpdateDevices(tx, devices...) err = d.insertOrUpdateDevices(tx, devices...)
if err != nil { if err != nil {
@ -140,10 +147,16 @@ func (d *SQLite) insertOrUpdateDevices(tx *sql.Tx, devices ...*types.Device) err
if err != nil { if err != nil {
return fmt.Errorf("Failed to prepare statement: %v", err) return fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, device := range devices { for _, device := range devices {
_, err = stmt.Exec(&device.ID, &device.Name, &device.Location, &device.CreationDate, &device.UpdateDate) _, err = stmt.Exec(
&device.ID,
&device.Name,
&device.Location,
&device.CreationDate,
&device.UpdateDate,
)
if err != nil { if err != nil {
return fmt.Errorf("Failed to execute statement: %v", err) return fmt.Errorf("Failed to execute statement: %v", err)
} }
@ -170,7 +183,7 @@ func (d *SQLite) AddMeasuredValues(ctx context.Context, measuredValues ...*types
if err != nil { if err != nil {
return fmt.Errorf("Failed to begin new transaction: %v", err) return fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
for measuredValueType, measuredValues := range splittedMeasuredValues { for measuredValueType, measuredValues := range splittedMeasuredValues {
var query string var query string
@ -200,7 +213,7 @@ func (d *SQLite) insertMeasuredValues(tx *sql.Tx, query string, measuredValues .
if err != nil { if err != nil {
return fmt.Errorf("Failed to prepare statement: %v", err) return fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, measuredValue := range measuredValues { for _, measuredValue := range measuredValues {
_, err := stmt.Exec( _, err := stmt.Exec(
@ -211,7 +224,6 @@ func (d *SQLite) insertMeasuredValues(tx *sql.Tx, query string, measuredValues .
&measuredValue.CreationDate, &measuredValue.CreationDate,
&measuredValue.UpdateDate, &measuredValue.UpdateDate,
) )
if err != nil { if err != nil {
return fmt.Errorf("Failed to execute statement: %v", err) return fmt.Errorf("Failed to execute statement: %v", err)
} }
@ -238,7 +250,7 @@ func (d *SQLite) AddOrUpdateMeasuredValues(ctx context.Context, measuredValues .
if err != nil { if err != nil {
return fmt.Errorf("Failed to begin new transaction: %v", err) return fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
for measuredValueType, measuredValues := range splittedMeasuredValues { for measuredValueType, measuredValues := range splittedMeasuredValues {
var query string var query string
@ -268,7 +280,7 @@ func (d *SQLite) insertOrUpdateMeasuredValues(tx *sql.Tx, query string, measured
if err != nil { if err != nil {
return fmt.Errorf("Failed to prepare statement: %v", err) return fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, measuredValue := range measuredValues { for _, measuredValue := range measuredValues {
_, err := stmt.Exec( _, err := stmt.Exec(
@ -297,13 +309,13 @@ func (d *SQLite) AddSensors(ctx context.Context, sensors ...*types.Sensor) error
if err != nil { if err != nil {
return fmt.Errorf("Failed to begin new transaction: %v", err) return fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
stmt, err := tx.Prepare(sqlite3.InsertSensorSQL) stmt, err := tx.Prepare(sqlite3.InsertSensorSQL)
if err != nil { if err != nil {
return fmt.Errorf("Failed to prepare statement: %v", err) return fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, sensor := range sensors { for _, sensor := range sensors {
_, err = stmt.Exec( _, err = stmt.Exec(
@ -338,7 +350,7 @@ func (d *SQLite) AddOrUpdateSensors(ctx context.Context, sensors ...*types.Senso
if err != nil { if err != nil {
return fmt.Errorf("Failed to begin new transaction: %v", err) return fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
err = d.insertOrUpdateSensors(tx, sensors...) err = d.insertOrUpdateSensors(tx, sensors...)
if err != nil { if err != nil {
@ -353,7 +365,7 @@ func (d *SQLite) insertOrUpdateSensors(tx *sql.Tx, sensors ...*types.Sensor) err
if err != nil { if err != nil {
return fmt.Errorf("Failed to prepare statement: %v", err) return fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, sensor := range sensors { for _, sensor := range sensors {
_, err = stmt.Exec( _, err = stmt.Exec(
@ -420,7 +432,7 @@ func (d *SQLite) GetDeviceByID(ctx context.Context, id string) (*types.Device, e
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to begin new transaction: %v", err) return nil, fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
devices, err := d.selectDevices(tx, sqlite3.SelectDeviceByIDSQL, id) devices, err := d.selectDevices(tx, sqlite3.SelectDeviceByIDSQL, id)
if err != nil { if err != nil {
@ -448,7 +460,7 @@ func (d *SQLite) GetDeviceByName(ctx context.Context, name string) (*types.Devic
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to begin new transaction: %v", err) return nil, fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
devices, err := d.selectDevices(tx, sqlite3.SelectDeviceByNameSQL, name) devices, err := d.selectDevices(tx, sqlite3.SelectDeviceByNameSQL, name)
if err != nil { if err != nil {
@ -476,7 +488,7 @@ func (d *SQLite) GetDevices(ctx context.Context) ([]*types.Device, error) {
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to begin new transaction: %v", err) return nil, fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
devices, err := d.selectDevices(tx, sqlite3.SelectDevicesSQL) devices, err := d.selectDevices(tx, sqlite3.SelectDevicesSQL)
if err != nil { if err != nil {
@ -496,13 +508,13 @@ func (d *SQLite) selectDevices(tx *sql.Tx, query string, args ...interface{}) ([
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to prepare statement: %v", err) return nil, fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
rows, err := stmt.Query(args...) rows, err := stmt.Query(args...)
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to query statement: %v", err) return nil, fmt.Errorf("Failed to query statement: %v", err)
} }
defer rows.Close() defer func() { _ = rows.Close() }()
devices := make([]*types.Device, 0) devices := make([]*types.Device, 0)
for rows.Next() { for rows.Next() {
@ -520,6 +532,10 @@ func (d *SQLite) selectDevices(tx *sql.Tx, query string, args ...interface{}) ([
devices = append(devices, device) devices = append(devices, device)
} }
if err := rows.Err(); err != nil {
return nil, fmt.Errorf("failed to scan rows: %v", err)
}
return devices, nil return devices, nil
} }
@ -532,7 +548,7 @@ func (d *SQLite) GetHumidityByID(ctx context.Context, id string) (*types.Measure
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
measuredValues, err := d.selectMeasuredValue(tx, sqlite3.SelectHumidityByIDSQL, id) measuredValues, err := d.selectMeasuredValue(tx, sqlite3.SelectHumidityByIDSQL, id)
if err != nil { if err != nil {
@ -564,7 +580,7 @@ func (d *SQLite) GetHumidities(ctx context.Context) ([]*types.MeasuredValue, err
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
measuredValues, err := d.selectMeasuredValue(tx, sqlite3.SelectHumiditiesSQL) measuredValues, err := d.selectMeasuredValue(tx, sqlite3.SelectHumiditiesSQL)
if err != nil { if err != nil {
@ -588,17 +604,18 @@ func (d *SQLite) selectMeasuredValue(tx *sql.Tx, query string, args ...interface
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
rows, err := stmt.Query(args...) rows, err := stmt.Query(args...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer rows.Close() defer func() { _ = rows.Close() }()
measuredValues := make([]*types.MeasuredValue, 0) measuredValues := make([]*types.MeasuredValue, 0)
for rows.Next() { for rows.Next() {
measuredValue := new(types.MeasuredValue) measuredValue := new(types.MeasuredValue)
err := rows.Scan( err := rows.Scan(
&measuredValue.ID, &measuredValue.ID,
&measuredValue.Value, &measuredValue.Value,
@ -607,7 +624,6 @@ func (d *SQLite) selectMeasuredValue(tx *sql.Tx, query string, args ...interface
&measuredValue.CreationDate, &measuredValue.CreationDate,
&measuredValue.UpdateDate, &measuredValue.UpdateDate,
) )
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -615,6 +631,10 @@ func (d *SQLite) selectMeasuredValue(tx *sql.Tx, query string, args ...interface
measuredValues = append(measuredValues, measuredValue) measuredValues = append(measuredValues, measuredValue)
} }
if err := rows.Err(); err != nil {
return nil, fmt.Errorf("failed to scan rows: %v", err)
}
return measuredValues, nil return measuredValues, nil
} }
@ -627,7 +647,7 @@ func (d *SQLite) GetPressureByID(ctx context.Context, id string) (*types.Measure
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
measuredValues, err := d.selectMeasuredValue(tx, sqlite3.SelectPressureByIDSQL, id) measuredValues, err := d.selectMeasuredValue(tx, sqlite3.SelectPressureByIDSQL, id)
if err != nil { if err != nil {
@ -659,7 +679,7 @@ func (d *SQLite) GetPressures(ctx context.Context) ([]*types.MeasuredValue, erro
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
measuredValues, err := d.selectMeasuredValue(tx, sqlite3.SelectPressuresSQL) measuredValues, err := d.selectMeasuredValue(tx, sqlite3.SelectPressuresSQL)
if err != nil { if err != nil {
@ -687,7 +707,7 @@ func (d *SQLite) GetSensorByID(ctx context.Context, id string) (*types.Sensor, e
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to begin new transaction: %v", err) return nil, fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
sensors, err := d.selectSensors(tx, sqlite3.SelectSensorByIDSQL, id) sensors, err := d.selectSensors(tx, sqlite3.SelectSensorByIDSQL, id)
if err != nil { if err != nil {
@ -715,7 +735,7 @@ func (d *SQLite) GetSensors(ctx context.Context) ([]*types.Sensor, error) {
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to begin new transaction: %v", err) return nil, fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
sensors, err := d.selectSensors(tx, sqlite3.SelectSensorsSQL) sensors, err := d.selectSensors(tx, sqlite3.SelectSensorsSQL)
if err != nil { if err != nil {
@ -739,7 +759,7 @@ func (d *SQLite) GetSensorsByDeviceIDs(ctx context.Context, deviceIDs ...string)
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to begin new transaction: %v", err) return nil, fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
cachedSensors := make([]*types.Sensor, 0) cachedSensors := make([]*types.Sensor, 0)
for i := range deviceIDs { for i := range deviceIDs {
@ -768,7 +788,7 @@ func (d *SQLite) GetSensorsByModels(ctx context.Context, sensorModels ...string)
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to begin new transaction: %v", err) return nil, fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
cachedSensors := make([]*types.Sensor, 0) cachedSensors := make([]*types.Sensor, 0)
for i := range sensorModels { for i := range sensorModels {
@ -797,7 +817,7 @@ func (d *SQLite) GetSensorsByNames(ctx context.Context, sensorNames ...string) (
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to begin new transaction: %v", err) return nil, fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
cachedSensors := make([]*types.Sensor, 0) cachedSensors := make([]*types.Sensor, 0)
for i := range sensorNames { for i := range sensorNames {
@ -822,13 +842,13 @@ func (d *SQLite) selectSensors(tx *sql.Tx, query string, args ...interface{}) ([
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to prepare statement: %v", err) return nil, fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
rows, err := stmt.Query(args...) rows, err := stmt.Query(args...)
if err != nil { if err != nil {
return nil, fmt.Errorf("Failed to query statement: %v", err) return nil, fmt.Errorf("Failed to query statement: %v", err)
} }
defer rows.Close() defer func() { _ = rows.Close() }()
sensors := make([]*types.Sensor, 0) sensors := make([]*types.Sensor, 0)
for rows.Next() { for rows.Next() {
@ -855,6 +875,10 @@ func (d *SQLite) selectSensors(tx *sql.Tx, query string, args ...interface{}) ([
sensors = append(sensors, sensor) sensors = append(sensors, sensor)
} }
if err := rows.Err(); err != nil {
return nil, fmt.Errorf("failed to scan rows: %v", err)
}
return sensors, nil return sensors, nil
} }
@ -867,7 +891,7 @@ func (d *SQLite) GetTemperatureByID(ctx context.Context, id string) (*types.Meas
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
measuredValues, err := d.selectMeasuredValue(tx, sqlite3.SelectTemperatureByIDSQL, id) measuredValues, err := d.selectMeasuredValue(tx, sqlite3.SelectTemperatureByIDSQL, id)
if err != nil { if err != nil {
@ -899,7 +923,7 @@ func (d *SQLite) GetTemperatures(ctx context.Context) ([]*types.MeasuredValue, e
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
measuredValues, err := d.selectMeasuredValue(tx, sqlite3.SelectTemperaturesSQL) measuredValues, err := d.selectMeasuredValue(tx, sqlite3.SelectTemperaturesSQL)
if err != nil { if err != nil {
@ -928,7 +952,7 @@ func (d *SQLite) Import(ctx context.Context, src Repository) error {
if err != nil { if err != nil {
return err return err
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
devices, err := src.GetDevices(ctx) devices, err := src.GetDevices(ctx)
if err != nil { if err != nil {
@ -981,13 +1005,13 @@ func (d *SQLite) RemoveDevicesByIDs(ctx context.Context, deviceIDs ...string) er
if err != nil { if err != nil {
return fmt.Errorf("Failed to begin new transaction: %v", err) return fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
stmt, err := tx.Prepare(sqlite3.DeleteDeviceByIDSQL) stmt, err := tx.Prepare(sqlite3.DeleteDeviceByIDSQL)
if err != nil { if err != nil {
return fmt.Errorf("Failed to prepare statement: %v", err) return fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, deviceID := range deviceIDs { for _, deviceID := range deviceIDs {
_, err = stmt.Exec(deviceID) _, err = stmt.Exec(deviceID)
@ -1008,13 +1032,13 @@ func (d *SQLite) RemoveDevicesByNames(ctx context.Context, names ...string) erro
if err != nil { if err != nil {
return fmt.Errorf("Failed to begin new transaction: %v", err) return fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
stmt, err := tx.Prepare(sqlite3.DeleteDeviceByNameSQL) stmt, err := tx.Prepare(sqlite3.DeleteDeviceByNameSQL)
if err != nil { if err != nil {
return fmt.Errorf("Failed to prepare statement: %v", err) return fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, deviceID := range names { for _, deviceID := range names {
_, err = stmt.Exec(deviceID) _, err = stmt.Exec(deviceID)
@ -1035,13 +1059,13 @@ func (d *SQLite) RemoveSensorsByIDs(ctx context.Context, sensorIDs ...string) er
if err != nil { if err != nil {
return fmt.Errorf("Failed to begin new transaction: %v", err) return fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
stmt, err := tx.Prepare(sqlite3.DeleteSensorByIDSQL) stmt, err := tx.Prepare(sqlite3.DeleteSensorByIDSQL)
if err != nil { if err != nil {
return fmt.Errorf("Failed to prepare statement: %v", err) return fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, sensorID := range sensorIDs { for _, sensorID := range sensorIDs {
_, err = stmt.Exec(sensorID) _, err = stmt.Exec(sensorID)
@ -1062,13 +1086,13 @@ func (d *SQLite) RemoveSensorsByNames(ctx context.Context, names ...string) erro
if err != nil { if err != nil {
return fmt.Errorf("Failed to begin new transaction: %v", err) return fmt.Errorf("Failed to begin new transaction: %v", err)
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
stmt, err := tx.Prepare(sqlite3.DeleteSensorByNameSQL) stmt, err := tx.Prepare(sqlite3.DeleteSensorByNameSQL)
if err != nil { if err != nil {
return fmt.Errorf("Failed to prepare statement: %v", err) return fmt.Errorf("Failed to prepare statement: %v", err)
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, sensorID := range names { for _, sensorID := range names {
_, err = stmt.Exec(sensorID) _, err = stmt.Exec(sensorID)
@ -1089,13 +1113,13 @@ func (d *SQLite) UpdateDevices(ctx context.Context, devices ...*types.Device) er
if err != nil { if err != nil {
return err return err
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
stmt, err := tx.Prepare(sqlite3.UpdateDeviceSQL) stmt, err := tx.Prepare(sqlite3.UpdateDeviceSQL)
if err != nil { if err != nil {
return err return err
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, device := range devices { for _, device := range devices {
_, err := stmt.Exec( _, err := stmt.Exec(
@ -1122,13 +1146,13 @@ func (d *SQLite) UpdateSensors(ctx context.Context, sensors ...*types.Sensor) er
if err != nil { if err != nil {
return err return err
} }
defer tx.Rollback() defer func() { _ = tx.Rollback() }()
stmt, err := tx.Prepare(sqlite3.UpdateSensorSQL) stmt, err := tx.Prepare(sqlite3.UpdateSensorSQL)
if err != nil { if err != nil {
return err return err
} }
defer stmt.Close() defer func() { _ = stmt.Close() }()
for _, sensor := range sensors { for _, sensor := range sensors {
_, err := stmt.Exec( _, err := stmt.Exec(

View File

@ -21,7 +21,6 @@ type BME280 struct {
// Read measured values // Read measured values
func (bme280 *BME280) Read() ([]*types.MeasuredValue, error) { func (bme280 *BME280) Read() ([]*types.MeasuredValue, error) {
// Lock multiple access // Lock multiple access
bme280.mutex.Lock() bme280.mutex.Lock()
defer bme280.mutex.Unlock() defer bme280.mutex.Unlock()

View File

@ -18,7 +18,6 @@ type DHT11 struct {
// Read measured values // Read measured values
func (dht11 *DHT11) Read() ([]*types.MeasuredValue, error) { func (dht11 *DHT11) Read() ([]*types.MeasuredValue, error) {
// Lock multiple access // Lock multiple access
dht11.mutex.Lock() dht11.mutex.Lock()
defer dht11.mutex.Unlock() defer dht11.mutex.Unlock()

View File

@ -18,7 +18,6 @@ type DHT22 struct {
// Read measured values // Read measured values
func (dht22 *DHT22) Read() ([]*types.MeasuredValue, error) { func (dht22 *DHT22) Read() ([]*types.MeasuredValue, error) {
// Lock multiple access // Lock multiple access
dht22.mutex.Lock() dht22.mutex.Lock()
defer dht22.mutex.Unlock() defer dht22.mutex.Unlock()

View File

@ -22,7 +22,6 @@ type DS18B20 struct {
// Read measured values // Read measured values
func (ds18b20 *DS18B20) Read() ([]*types.MeasuredValue, error) { func (ds18b20 *DS18B20) Read() ([]*types.MeasuredValue, error) {
// Lock multiple access // Lock multiple access
ds18b20.mutex.Lock() ds18b20.mutex.Lock()
defer ds18b20.mutex.Unlock() defer ds18b20.mutex.Unlock()
@ -36,6 +35,7 @@ func (ds18b20 *DS18B20) Read() ([]*types.MeasuredValue, error) {
return nil, fmt.Errorf("Socket path not found: %v", socketPath) return nil, fmt.Errorf("Socket path not found: %v", socketPath)
} }
/* #nosec */
data, err := ioutil.ReadFile(socketPath) data, err := ioutil.ReadFile(socketPath)
if err != nil { if err != nil {
return nil, fmt.Errorf("Can not read data from sensor %v", ds18b20.Name) return nil, fmt.Errorf("Can not read data from sensor %v", ds18b20.Name)

View File

@ -14,7 +14,7 @@ var (
// FilterMeasuredValuesByTypes filters measured values by type // FilterMeasuredValuesByTypes filters measured values by type
func FilterMeasuredValuesByTypes(ctx context.Context, inChannel <-chan *types.MeasuredValue, measuredValueTypes ...types.MeasuredValueType) <-chan *types.MeasuredValue { func FilterMeasuredValuesByTypes(ctx context.Context, inChannel <-chan *types.MeasuredValue, measuredValueTypes ...types.MeasuredValueType) <-chan *types.MeasuredValue {
outChannel := make(chan *types.MeasuredValue, 0) outChannel := make(chan *types.MeasuredValue, 1)
go func() { go func() {
LOOP: LOOP:
for { for {
@ -40,7 +40,7 @@ func FilterMeasuredValuesByTypes(ctx context.Context, inChannel <-chan *types.Me
// FilterMeasuredValuesBySensorIDs filters measured values by sensor id // FilterMeasuredValuesBySensorIDs filters measured values by sensor id
func FilterMeasuredValuesBySensorIDs(ctx context.Context, inChannel <-chan *types.MeasuredValue, sensorIDs ...string) <-chan *types.MeasuredValue { func FilterMeasuredValuesBySensorIDs(ctx context.Context, inChannel <-chan *types.MeasuredValue, sensorIDs ...string) <-chan *types.MeasuredValue {
outChannel := make(chan *types.MeasuredValue, 0) outChannel := make(chan *types.MeasuredValue, 1)
go func() { go func() {
LOOP: LOOP:
for { for {
@ -68,8 +68,8 @@ func FilterMeasuredValuesBySensorIDs(ctx context.Context, inChannel <-chan *type
// closed. The returned channels will be closed // closed. The returned channels will be closed
func ReadPipeline(ctx context.Context, sensors ...Sensor) (<-chan *types.MeasuredValue, <-chan error) { func ReadPipeline(ctx context.Context, sensors ...Sensor) (<-chan *types.MeasuredValue, <-chan error) {
var ( var (
errorChannel = make(chan error, 0) errorChannel = make(chan error, 1)
measuredValueChannel = make(chan *types.MeasuredValue, 0) measuredValueChannel = make(chan *types.MeasuredValue, 1)
) )
go func() { go func() {
@ -102,8 +102,8 @@ func ReadPipeline(ctx context.Context, sensors ...Sensor) (<-chan *types.Measure
// the context has been closed // the context has been closed
func ReadTickingPipeline(ctx context.Context, sensors ...Sensor) (<-chan *types.MeasuredValue, <-chan error) { func ReadTickingPipeline(ctx context.Context, sensors ...Sensor) (<-chan *types.MeasuredValue, <-chan error) {
var ( var (
errorChannel = make(chan error, 0) errorChannel = make(chan error, 1)
measuredValueChannel = make(chan *types.MeasuredValue, 0) measuredValueChannel = make(chan *types.MeasuredValue, 1)
) )
for i := range sensors { for i := range sensors {

View File

@ -9,7 +9,7 @@ import (
// or temperature. // or temperature.
type MeasuredValue struct { type MeasuredValue struct {
ID string `json:"id" xml:"id"` ID string `json:"id" xml:"id"`
Value float64 `json:"value,string" xml:"value,string"` Value float64 `json:"value,string" xml:"value"`
ValueType MeasuredValueType `json:"value_type" xml:"value_type"` ValueType MeasuredValueType `json:"value_type" xml:"value_type"`
Date time.Time `json:"date" xml:"date"` Date time.Time `json:"date" xml:"date"`
SensorID string `json:"sensor_id" xml:"sensor_id"` SensorID string `json:"sensor_id" xml:"sensor_id"`
@ -21,6 +21,6 @@ type MeasuredValueType string
const ( const (
Humidity MeasuredValueType = "humidity" Humidity MeasuredValueType = "humidity"
Pressure = "pressure" Pressure MeasuredValueType = "pressure"
Temperature = "temperature" Temperature MeasuredValueType = "temperature"
) )