fix(pkg/daemon): save measured values into postgres database if defined

pkg/config/dbsettings.go

@@ -0,0 +1,21 @@
+package config
+
+type DatabaseSettings struct {
+	Vendor   DatabaseVendor `json:"vendor"`
+	Host     string         `json:"host"`
+	Port     string         `json:"port"`
+	Database string         `json:"database"`
+	User     string         `json:"user"`
+	Password string         `json:"password"`
+}
+
+type DatabaseVendor string
+
+func (dv DatabaseVendor) String() string {
+	return string(dv)
+}
+
+const (
+	VendorPostgreSQL DatabaseVendor = "postgres"
+	VendorOracle                    = "oracle"
+)

pkg/config/flucky.go

@@ -32,9 +32,11 @@ var temperatureSensorModels = map[types.SensorModel]types.SensorModel{
 
 // Configuration of flucky
 type Configuration struct {
-	Device  *types.Device   `json:"device"`
-	RGBLEDs []*types.RGBLED `json:"rgb_leds"`
-	Sensors []*types.Sensor `json:"sensors"`
+	DatabaseSettings *DatabaseSettings `json:"database_settings"`
+	Device           *types.Device     `json:"device"`
+	Logfile          string            `json:"logfile" xml:"logfile"`
+	RGBLEDs          []*types.RGBLED   `json:"rgb_leds"`
+	Sensors          []*types.Sensor   `json:"sensors"`
 }
 
 // AddRGBLED add a new RGBLED
@@ -451,6 +453,11 @@ func (c *Configuration) GetTemperatureSensorsByName(names []string) []sensor.Sen
 	return c.convertSensors(temperatureSensors)
 }
 
+// RemoveDatabaseSettings remove data base setting informations
+func (c *Configuration) RemoveDatabaseSettings() {
+	c.DatabaseSettings = nil
+}
+
 // RemoveRGBLED deletes a LED by its name or its unique UUID
 func (c *Configuration) RemoveRGBLED(name string) error {
 	for i, rgbLED := range c.RGBLEDs {
@@ -513,6 +520,11 @@ func (c *Configuration) RenameSensor(oldName, newName string) error {
 	return fmt.Errorf("Could not find remote %v to replace into with %v", oldName, newName)
 }
 
+// SetDatabaseSettings set database setting informations
+func (c *Configuration) SetDatabaseSettings(databaseSettings *DatabaseSettings) {
+	c.DatabaseSettings = databaseSettings
+}
+
 func (c *Configuration) convertSensors(sensors []*types.Sensor) []sensor.Sensor {
 	cachedSensors := make([]sensor.Sensor, 0)
 

pkg/daemon/daemon.go

@@ -7,12 +7,13 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/Masterminds/semver"
 	"github.com/go-flucky/flucky/pkg/config"
-	"github.com/go-flucky/flucky/pkg/db"
-	"github.com/go-flucky/flucky/pkg/logfile"
 	"github.com/go-flucky/flucky/pkg/logger"
 	"github.com/go-flucky/flucky/pkg/rgbled"
 	"github.com/go-flucky/flucky/pkg/sensor"
+	"github.com/go-flucky/flucky/pkg/storage/db"
+	"github.com/go-flucky/flucky/pkg/storage/logfile"
 	"github.com/go-flucky/flucky/pkg/types"
 )
 
@@ -22,15 +23,25 @@ var (
 	postgresDatabase = "postgres"
 	postgresUser     = "postgres"
 	postgresPassword = "postgres"
+
+	flogger logger.Logger
 )
 
+func init() {
+	flogger = logger.NewSilentLogger()
+}
+
+func SetLogger(logger logger.Logger) {
+	flogger = logger
+}
+
 // Start the daemon
-func Start(cnf *config.Configuration, cleanCacheInterval time.Duration, compression bool, round float64, logger logger.Logger) {
+func Start(cnf *config.Configuration, cleanCacheInterval time.Duration, compression bool, round float64, version *semver.Version) {
 
 	// Info
-	logger.Info("Use clean-cache-interval: %v", cleanCacheInterval.String())
-	logger.Info("Use compression: %v", compression)
-	logger.Info("Round: %v", round)
+	flogger.Info("Use clean-cache-interval: %v", cleanCacheInterval.String())
+	flogger.Info("Use compression: %v", compression)
+	flogger.Info("Round: %v", round)
 
 	ticker := time.Tick(cleanCacheInterval)
 
@@ -43,29 +54,44 @@ func Start(cnf *config.Configuration, cleanCacheInterval time.Duration, compress
 	ctx := context.Background()
 	childContext, cancel := context.WithCancel(ctx)
 
-	measuredValuesLogfile := logfile.New(cnf.Device.Logfile)
+	measuredValuesLogfile := logfile.New(cnf.Logfile)
 
 	measuredValuesCache := make([]*types.MeasuredValue, 0)
 
-	go sensor.ReadContinuously(childContext, cnf.GetSensors(config.ENABLED), measuredValuesChannel, errorChannel)
+	var postgres db.Database
+	if cnf.DatabaseSettings != nil {
+		p, err := db.New(cnf.DatabaseSettings)
+		if err != nil {
+			flogger.Error("%v", err)
+		}
+		if err := p.Schema(ctx, version); err != nil {
+			flogger.Error("%v", err)
+		}
+		postgres = p
+		checkDeviceInDatabase(ctx, cnf.Device, postgres)
+		checkSensorsInDatabase(ctx, cnf.Sensors, postgres)
+		defer postgres.Close()
+	}
 
 	rgbLEDs := cnf.GetRGBLEDs(config.ENABLED)
 
+	go sensor.ReadContinuously(childContext, cnf.GetSensors(config.ENABLED), measuredValuesChannel, errorChannel)
+
 	for {
 
 		err := rgbled.Run(rgbLEDs)
 		if err != nil {
-			logger.Error("Can not turn on green info light: %v", err)
+			flogger.Error("Can not turn on green info light: %v", err)
 		}
 
 		select {
 		case err, _ := <-errorChannel:
 
-			logger.Error("%v", err)
+			flogger.Error("%v", err)
 
 			err = rgbled.Error(rgbLEDs)
 			if err != nil {
-				logger.Error("Can not turn on red info light: %v", err)
+				flogger.Error("Can not turn on red info light: %v", err)
 			}
 
 			time.Sleep(time.Second * 2)
@@ -73,34 +99,25 @@ func Start(cnf *config.Configuration, cleanCacheInterval time.Duration, compress
 		case <-ticker:
 			err := rgbled.Logfile(rgbLEDs)
 			if err != nil {
-				logger.Error("Can not turn on blue info light: %v", err)
+				flogger.Error("Can not turn on blue info light: %v", err)
 			}
 
-			// err = logfile.Append(measuredValuesLogfile, compression, round, measuredValuesCache)
-
-			postgres, err := db.New(db.DBOTypePostgres, postgresHost, postgresPort, postgresDatabase, postgresUser, postgresPassword)
-			if err != nil {
-
-				err = rgbled.Error(rgbLEDs)
-				if err != nil {
-					logger.Error("Can not turn on red info light: %v", err)
+			if err := logfile.Append(measuredValuesLogfile, compression, round, measuredValuesCache); err != nil {
+				err2 := rgbled.Error(rgbLEDs)
+				if err2 != nil {
+					flogger.Error("Can not turn on red info light: %v", err2)
 				}
-
-				cancel()
-				logger.Error("Can not open database connection: %v", err)
+				flogger.Error("Can not save caches measured values in logfile: %v", err)
 			}
 
-			postgresCtx := context.Background()
-			err = postgres.InsertMeasuredValues(postgresCtx, measuredValuesCache)
-			if err != nil {
-
-				err = rgbled.Error(rgbLEDs)
-				if err != nil {
-					logger.Error("Can not turn on red info light: %v", err)
+			if postgres != nil {
+				if err := postgres.InsertMeasuredValues(ctx, measuredValuesCache); err != nil {
+					err2 := rgbled.Error(rgbLEDs)
+					if err2 != nil {
+						flogger.Error("Can not turn on red info light: %v", err)
+					}
+					flogger.Error("Can not save cached measured values in database: %v", err)
 				}
-
-				cancel()
-				logger.Error("Can not save caches measured values in database: %v", err)
 			}
 
 			measuredValuesCache = make([]*types.MeasuredValue, 0)
@@ -109,22 +126,52 @@ func Start(cnf *config.Configuration, cleanCacheInterval time.Duration, compress
 			measuredValuesCache = append(measuredValuesCache, measuredValues...)
 
 		case killSignal := <-interrupt:
-			logger.Warn("Daemon was interruped by system signal %v\n", killSignal)
+			flogger.Warn("Daemon was interruped by system signal %v\n", killSignal)
 
 			cancel()
 
 			err := rgbled.Error(rgbLEDs)
 			if err != nil {
-				logger.Error("Can not turn on red info light: %v", err)
+				flogger.Error("Can not turn on red info light: %v", err)
 			}
 
-			logger.Warn("Save remaining data from the cache")
+			flogger.Warn("Save remaining data from the cache")
 			err = logfile.Append(measuredValuesLogfile, compression, round, measuredValuesCache)
 			if err != nil {
-				logger.Fatal("%v", err)
+				flogger.Fatal("%v", err)
 			}
 
 			return
 		}
 	}
 }
+
+func checkDeviceInDatabase(ctx context.Context, device *types.Device, database db.Database) {
+	_, err := database.SelectDeviceByID(ctx, device.DeviceID)
+	if err != nil {
+		flogger.Debug("It's seems the current device is not registered in the database. Register the device now")
+		err2 := database.InsertDevices(ctx, []*types.Device{device})
+		if err2 != nil {
+			flogger.Fatal("Can not register device into database: %v", err2)
+		}
+		flogger.Debug("Device successfully registered into the database")
+		return
+	}
+	flogger.Debug("Device already registered into the database")
+}
+
+func checkSensorsInDatabase(ctx context.Context, sensors []*types.Sensor, database db.Database) {
+	for _, sensor := range sensors {
+		_, err := database.SelectSensorByID(ctx, sensor.SensorID)
+		if err != nil {
+			flogger.Debug("It's seems the sensor %v is not registered in the database. Register the sensor now", sensor.SensorName)
+			err2 := database.InsertSensors(ctx, []*types.Sensor{sensor})
+			if err2 != nil {
+				flogger.Fatal("Can not register sensor %v into database: %v", sensor.SensorName, err2)
+			}
+			flogger.Debug("Sensor %v successfully registered into the database", sensor.SensorName)
+			continue
+		}
+		flogger.Debug("Sensor %v is already registered into the database", sensor.SensorName)
+	}
+}

pkg/db/db.go

@@ -1,25 +0,0 @@
-package db
-
-import (
-	"database/sql"
-	"fmt"
-
-	_ "github.com/lib/pq"
-)
-
-func New(dboType DBOType, host string, port string, database string, user string, password string) (Database, error) {
-	connStr := fmt.Sprintf("%v://%v:%v@%v:%v/%v?sslmode=disable", dboType.String(), user, password, host, port, database)
-	newDBO, err := sql.Open(dboType.String(), connStr)
-	if err != nil {
-		return nil, err
-	}
-
-	switch dboType {
-	case "postgres":
-		return &Postgres{
-			dbo: newDBO,
-		}, nil
-	default:
-		return nil, fmt.Errorf("Unknown Database Type")
-	}
-}

pkg/db/dbotype.go

@@ -1,12 +0,0 @@
-package db
-
-type DBOType string
-
-func (dboType DBOType) String() string {
-	return string(dboType)
-}
-
-const (
-	DBOTypePostgres DBOType = "postgres"
-	DBOTypeOracle           = "oracle"
-)

pkg/db/schema.go

@@ -1,10 +0,0 @@
-package db
-
-var (
-	postgreSQLSchemata []*schemaInformation
-)
-
-type schemaInformation struct {
-	Version string
-	Asset   string
-}

pkg/storage/db/db.go

@@ -0,0 +1,39 @@
+package db
+
+import (
+	"database/sql"
+	"fmt"
+
+	"github.com/go-flucky/flucky/pkg/config"
+	"github.com/go-flucky/flucky/pkg/logger"
+	_ "github.com/lib/pq"
+)
+
+var (
+	flogger logger.Logger
+)
+
+func init() {
+	flogger = logger.NewSilentLogger()
+}
+
+func New(databaseSettings *config.DatabaseSettings) (Database, error) {
+	connStr := fmt.Sprintf("%v://%v:%v@%v:%v/%v?sslmode=disable", databaseSettings.Vendor.String(), databaseSettings.User, databaseSettings.Password, databaseSettings.Host, databaseSettings.Port, databaseSettings.Database)
+	newDBO, err := sql.Open(databaseSettings.Vendor.String(), connStr)
+	if err != nil {
+		return nil, err
+	}
+
+	switch databaseSettings.Vendor {
+	case config.VendorPostgreSQL:
+		return &Postgres{
+			dbo: newDBO,
+		}, nil
+	default:
+		return nil, fmt.Errorf("Unknown Database Type")
+	}
+}
+
+func SetLogger(logger logger.Logger) {
+	flogger = logger
+}

pkg/storage/db/postgres.go

@@ -5,6 +5,7 @@ import (
 	"database/sql"
 	"fmt"
 	"path/filepath"
+	"sort"
 	"strings"
 
 	"github.com/Masterminds/semver"
@@ -13,71 +14,91 @@ import (
 	_ "github.com/lib/pq"
 )
 
+var (
+	postgresAssetPath = "pkg/storage/db/sql/psql"
+)
+
 type Postgres struct {
 	dbo *sql.DB
 }
 
 func (p *Postgres) Close() error {
-	return p.Close()
+	return p.dbo.Close()
 }
 
 // Schema create or upgrade database schema to the version of the flucky binary
 func (p *Postgres) Schema(ctx context.Context, version *semver.Version) error {
 
-	query := "SELECT value FROM info WHERE key='version';"
+	schemaFunc := func(ctx context.Context, fromVersion *semver.Version, toVersion *semver.Version) error {
 
-	stmt, err := p.dbo.PrepareContext(ctx, query)
-	if err != nil {
-
-		asset := "pkg/db/sql/psql/schema.sql"
-		queryBytes, err := Asset(asset)
+		assetPath := fmt.Sprintf("%v/schema", postgresAssetPath)
+		sqlAssetFiles, err := AssetDir(assetPath)
 		if err != nil {
-			return fmt.Errorf("%v: %v", errorGetAsset, err)
-		}
-		query = string(queryBytes)
-
-		_, err = p.dbo.ExecContext(ctx, query)
-		if err != nil {
-			return fmt.Errorf("%v: %v", errorStatementExecute, err)
+			return fmt.Errorf("Can not restore asset directory %v: %v", assetPath, err)
 		}
 
+		postgreSQLVersionChanges := make(map[*semver.Version]string, 0)
+		postgreSQLVersions := make([]*semver.Version, len(sqlAssetFiles))
+
+		for i, sqlAssetFile := range sqlAssetFiles {
+			fileSemVersion, err := semver.NewVersion(strings.ReplaceAll(sqlAssetFile, ".sql", ""))
+			if err != nil {
+				return fmt.Errorf("Can not create semantic version from file asset %v: %v", sqlAssetFile, err)
+			}
+			postgreSQLVersionChanges[fileSemVersion] = sqlAssetFile
+			postgreSQLVersions[i] = fileSemVersion
+		}
+		sort.Sort(semver.Collection(postgreSQLVersions))
+
+		for i, postgreSQLVersion := range postgreSQLVersions {
+			if fromVersion != nil {
+				if postgreSQLVersion.LessThan(fromVersion) || postgreSQLVersion.Equal(fromVersion) {
+					flogger.Debug("SKIP: PostgreSQL schema version '%v' is less or eqal then the local version changes '%v'", postgreSQLVersion.String(), fromVersion.String())
+					continue
+				}
+			}
+
+			asset := postgreSQLVersionChanges[postgreSQLVersion]
+			queryBytes, err := Asset(filepath.Join(assetPath, asset))
+			if err != nil {
+				return fmt.Errorf("Can not restore asset %v, %v", asset, err)
+			}
+			query := string(queryBytes)
+
+			if _, err := p.dbo.ExecContext(ctx, query); err != nil {
+				return fmt.Errorf("%v: %v", errorStatementExecute, err)
+			}
+
+			if i == 0 {
+				if err := p.InsertInfo(ctx, "version", postgreSQLVersion.String()); err != nil {
+					return fmt.Errorf("Can not insert version %v into info table: %v", postgreSQLVersion.String(), err)
+				}
+			} else {
+				if err := p.UpdateInfo(ctx, "version", postgreSQLVersion.String()); err != nil {
+					return fmt.Errorf("Can not update version %v into info table: %v", postgreSQLVersion.String(), err)
+				}
+			}
+		}
 		return nil
 	}
 
-	schemaVersion := ""
-	row := stmt.QueryRowContext(ctx)
-	err = row.Scan(&schemaVersion)
+	dbVersion, err := p.SelectInfo(ctx, "version")
 	if err != nil {
-		return fmt.Errorf("%v: %v", errorScanRow, err)
+		// can not select version from database, maybe the schema is not initialize
+		// create db schema for the current flucky version
+		return schemaFunc(ctx, nil, version)
+	} else {
+		fromVersion, err := semver.NewVersion(dbVersion)
+		if err != nil {
+			return fmt.Errorf("Can not create semantic version from database entry %v: %v", dbVersion, err)
+		}
+		return schemaFunc(ctx, fromVersion, version)
 	}
 
-	fromVersion, err := semver.NewVersion(schemaVersion)
-	if err != nil {
-		return fmt.Errorf("Can not create new sematic version from database: %v", err)
-	}
-
-	if err := schema(fromVersion, version); err != nil {
-		return err
-	}
-
-	// The result will be 0 if from == to, -1 if from < to, or +1 if from > to.
-	switch fromVersion.Compare(version) {
-	case -1:
-		return schema(fromVersion, version)
-	case 0:
-		// fromVersion and toVersion are equal
-		return nil
-	case 1:
-		// fromVersion < toVersion
-		return fmt.Errorf("Can not downgrade the database schema. Update the flucky binary")
-	}
-
-	return nil
-
 }
 
 func (p *Postgres) DeleteDevices(ctx context.Context, devices []*types.Device) error {
-	asset := "pkg/db/sql/psql/deleteDevice.sql"
+	asset := fmt.Sprintf("%v/deleteDevice.sql", postgresAssetPath)
 	queryBytes, err := Asset(asset)
 	if err != nil {
 		return fmt.Errorf("%v: %v", errorGetAsset, err)
@@ -101,7 +122,7 @@ func (p *Postgres) DeleteDevices(ctx context.Context, devices []*types.Device) e
 }
 
 func (p *Postgres) DeleteSensors(ctx context.Context, sensors []*types.Sensor) error {
-	asset := "pkg/db/sql/psql/deleteSensor.sql"
+	asset := fmt.Sprintf("%v/deleteSensor.sql", postgresAssetPath)
 	queryBytes, err := Asset(asset)
 	if err != nil {
 		return fmt.Errorf("%v: %v", errorGetAsset, err)
@@ -161,7 +182,7 @@ func (p *Postgres) DeleteMeasuredValues(ctx context.Context, measuredValues []*t
 	for measuredValueType, sortedMeasuredValues := range sortedMeasuredValueTypes {
 		switch measuredValueType {
 		case types.MeasuredValueTypeHumidity:
-			query, err := assetFunc("pkg/db/sql/psql/deleteHumidity.sql")
+			query, err := assetFunc(fmt.Sprintf("%v/deleteHumidity.sql", postgresAssetPath))
 			if err != nil {
 				return err
 			}
@@ -170,7 +191,7 @@ func (p *Postgres) DeleteMeasuredValues(ctx context.Context, measuredValues []*t
 				return err
 			}
 		case types.MeasuredValueTypePressure:
-			query, err := assetFunc("pkg/db/sql/psql/deletePressure.sql")
+			query, err := assetFunc(fmt.Sprintf("%v/deletePressure.sql", postgresAssetPath))
 			if err != nil {
 				return err
 			}
@@ -179,7 +200,7 @@ func (p *Postgres) DeleteMeasuredValues(ctx context.Context, measuredValues []*t
 				return err
 			}
 		case types.MeasuredValueTypeTemperature:
-			query, err := assetFunc("pkg/db/sql/psql/deleteTemperature.sql")
+			query, err := assetFunc(fmt.Sprintf("%v/deleteTemperature.sql", postgresAssetPath))
 			if err != nil {
 				return err
 			}
@@ -194,7 +215,7 @@ func (p *Postgres) DeleteMeasuredValues(ctx context.Context, measuredValues []*t
 }
 
 func (p *Postgres) InsertDevices(ctx context.Context, devices []*types.Device) error {
-	asset := "pkg/db/sql/psql/insertDevice.sql"
+	asset := fmt.Sprintf("%v/insertDevice.sql", postgresAssetPath)
 	queryBytes, err := Asset(asset)
 	if err != nil {
 		return fmt.Errorf("%v: %v", errorGetAsset, err)
@@ -217,6 +238,28 @@ func (p *Postgres) InsertDevices(ctx context.Context, devices []*types.Device) e
 	return nil
 }
 
+func (p *Postgres) InsertInfo(ctx context.Context, key string, value string) error {
+	asset := fmt.Sprintf("%v/insertInfo.sql", postgresAssetPath)
+	queryBytes, err := Asset(asset)
+	if err != nil {
+		return fmt.Errorf("%v: %v", errorGetAsset, err)
+	}
+	query := string(queryBytes)
+
+	stmt, err := p.dbo.PrepareContext(ctx, query)
+	if err != nil {
+		return fmt.Errorf("%v: %v", errorPrepareStatement, err)
+	}
+	defer stmt.Close()
+
+	_, err = stmt.ExecContext(ctx, key, value)
+	if err != nil {
+		return fmt.Errorf("%v: %v", errorStatementExecute, err)
+	}
+
+	return nil
+}
+
 func (p *Postgres) InsertMeasuredValues(ctx context.Context, measuredValues []*types.MeasuredValue) error {
 
 	sortedMeasuredValueTypes := make(map[types.MeasuredValueType][]*types.MeasuredValue)
@@ -250,7 +293,7 @@ func (p *Postgres) InsertMeasuredValues(ctx context.Context, measuredValues []*t
 
 func (p *Postgres) insertHumidity(ctx context.Context, measuredValues []*types.MeasuredValue) error {
 
-	asset := "pkg/db/sql/psql/insertHumidity.sql"
+	asset := fmt.Sprintf("%v/insertHumidity.sql", postgresAssetPath)
 	queryBytes, err := Asset(asset)
 	if err != nil {
 		return fmt.Errorf("%v: %v", errorGetAsset, err)
@@ -279,7 +322,7 @@ func (p *Postgres) insertHumidity(ctx context.Context, measuredValues []*types.M
 
 func (p *Postgres) insertPressure(ctx context.Context, measuredValues []*types.MeasuredValue) error {
 
-	asset := "pkg/db/sql/psql/insertPressure.sql"
+	asset := fmt.Sprintf("%v/insertPressure.sql", postgresAssetPath)
 	queryBytes, err := Asset(asset)
 	if err != nil {
 		return fmt.Errorf("%v: %v", errorGetAsset, err)
@@ -308,7 +351,7 @@ func (p *Postgres) insertPressure(ctx context.Context, measuredValues []*types.M
 
 func (p *Postgres) insertTemperature(ctx context.Context, measuredValues []*types.MeasuredValue) error {
 
-	asset := "pkg/db/sql/psql/insertTemperature.sql"
+	asset := fmt.Sprintf("%v/insertTemperature.sql", postgresAssetPath)
 	queryBytes, err := Asset(asset)
 	if err != nil {
 		return fmt.Errorf("%v: %v", errorGetAsset, err)
@@ -337,7 +380,7 @@ func (p *Postgres) insertTemperature(ctx context.Context, measuredValues []*type
 
 func (p *Postgres) InsertSensors(ctx context.Context, sensors []*types.Sensor) error {
 
-	asset := "pkg/db/sql/psql/insertSensor.sql"
+	asset := fmt.Sprintf("%v/insertSensor.sql", postgresAssetPath)
 	queryBytes, err := Asset(asset)
 	if err != nil {
 		return fmt.Errorf("%v: %v", errorGetAsset, err)
@@ -361,7 +404,7 @@ func (p *Postgres) InsertSensors(ctx context.Context, sensors []*types.Sensor) e
 }
 
 func (p *Postgres) SelectDeviceByID(ctx context.Context, id string) (*types.Device, error) {
-	asset := "pkg/db/sql/psql/selectDeviceByID.sql"
+	asset := fmt.Sprintf("%v/selectDeviceByID.sql", postgresAssetPath)
 	queryBytes, err := Asset(asset)
 	if err != nil {
 		return nil, fmt.Errorf("%v: %v", errorGetAsset, err)
@@ -387,21 +430,35 @@ func (p *Postgres) SelectDeviceByID(ctx context.Context, id string) (*types.Devi
 	return device, nil
 }
 
-func (p *Postgres) SelectMeasuredValuesByIDAndType(ctx context.Context, id string, valueType types.MeasuredValueType) (*types.MeasuredValue, error) {
-	switch valueType {
-	case types.MeasuredValueTypeHumidity:
-		return p.SelectHumidityByID(ctx, id)
-	case types.MeasuredValueTypePressure:
-		return p.SelectPressureByID(ctx, id)
-	case types.MeasuredValueTypeTemperature:
-		return p.SelectTemperatureByID(ctx, id)
-	default:
-		return nil, fmt.Errorf("%v: %v", errorUnknownMeasuredValueType, valueType)
+func (p *Postgres) SelectInfo(ctx context.Context, key string) (string, error) {
+	asset := fmt.Sprintf("%v/selectInfo.sql", postgresAssetPath)
+	queryBytes, err := Asset(asset)
+	if err != nil {
+		return "", fmt.Errorf("%v: %v", errorGetAsset, err)
 	}
+	query := string(queryBytes)
+
+	stmt, err := p.dbo.PrepareContext(ctx, query)
+	if err != nil {
+		return "", fmt.Errorf("%v: %v", errorPrepareStatement, err)
+	}
+
+	row := stmt.QueryRowContext(ctx, key)
+	if row == nil {
+		return "", errorRowNotFound
+	}
+
+	value := ""
+	err = row.Scan(&value)
+	if err != nil {
+		return "", fmt.Errorf("%v: %v", errorScanRow, err)
+	}
+
+	return value, nil
 }
 
 func (p *Postgres) SelectHumidities(ctx context.Context) ([]*types.MeasuredValue, error) {
-	queryFile := "pkg/db/sql/psql/selectHumidities.sql"
+	queryFile := fmt.Sprintf("%v/selectHumidities.sql", postgresAssetPath)
 	measuredValues, err := p.selectMeasuredValues(ctx, types.MeasuredValueTypeHumidity, queryFile, nil)
 	if err != nil {
 		return nil, err
@@ -410,7 +467,7 @@ func (p *Postgres) SelectHumidities(ctx context.Context) ([]*types.MeasuredValue
 }
 
 func (p *Postgres) SelectHumidityByID(ctx context.Context, id string) (*types.MeasuredValue, error) {
-	queryFile := "pkg/db/sql/psql/selectHumidityByID.sql"
+	queryFile := fmt.Sprintf("%v/selectHumidityByID.sql", postgresAssetPath)
 	args := []interface{}{id}
 	measuredValues, err := p.selectMeasuredValues(ctx, types.MeasuredValueTypeHumidity, queryFile, args)
 	if err != nil {
@@ -424,8 +481,21 @@ func (p *Postgres) SelectHumidityByID(ctx context.Context, id string) (*types.Me
 	return measuredValues[0], nil
 }
 
+func (p *Postgres) SelectMeasuredValuesByIDAndType(ctx context.Context, id string, valueType types.MeasuredValueType) (*types.MeasuredValue, error) {
+	switch valueType {
+	case types.MeasuredValueTypeHumidity:
+		return p.SelectHumidityByID(ctx, id)
+	case types.MeasuredValueTypePressure:
+		return p.SelectPressureByID(ctx, id)
+	case types.MeasuredValueTypeTemperature:
+		return p.SelectTemperatureByID(ctx, id)
+	default:
+		return nil, fmt.Errorf("%v: %v", errorUnknownMeasuredValueType, valueType)
+	}
+}
+
 func (p *Postgres) SelectPressures(ctx context.Context) ([]*types.MeasuredValue, error) {
-	queryFile := "pkg/db/sql/psql/selectPressures.sql"
+	queryFile := fmt.Sprintf("%v/selectPressures.sql", postgresAssetPath)
 	measuredValues, err := p.selectMeasuredValues(ctx, types.MeasuredValueTypePressure, queryFile, nil)
 	if err != nil {
 		return nil, err
@@ -434,7 +504,7 @@ func (p *Postgres) SelectPressures(ctx context.Context) ([]*types.MeasuredValue,
 }
 
 func (p *Postgres) SelectPressureByID(ctx context.Context, id string) (*types.MeasuredValue, error) {
-	queryFile := "pkg/db/sql/psql/selectPressureByID.sql"
+	queryFile := fmt.Sprintf("%v/selectPressureByID.sql", postgresAssetPath)
 	args := []interface{}{id}
 	measuredValues, err := p.selectMeasuredValues(ctx, types.MeasuredValueTypePressure, queryFile, args)
 	if err != nil {
@@ -449,7 +519,7 @@ func (p *Postgres) SelectPressureByID(ctx context.Context, id string) (*types.Me
 }
 
 func (p *Postgres) SelectSensorByID(ctx context.Context, id string) (*types.Sensor, error) {
-	asset := "pkg/db/sql/psql/selectSensorByID.sql"
+	asset := fmt.Sprintf("%v/selectSensorByID.sql", postgresAssetPath)
 	queryBytes, err := Asset(asset)
 	if err != nil {
 		return nil, fmt.Errorf("%v: %v", errorGetAsset, err)
@@ -476,7 +546,7 @@ func (p *Postgres) SelectSensorByID(ctx context.Context, id string) (*types.Sens
 }
 
 func (p *Postgres) SelectTemperatures(ctx context.Context) ([]*types.MeasuredValue, error) {
-	queryFile := "pkg/db/sql/psql/selectTemperatures.sql"
+	queryFile := fmt.Sprintf("%v/selectTemperatures.sql", postgresAssetPath)
 	measuredValues, err := p.selectMeasuredValues(ctx, types.MeasuredValueTypeTemperature, queryFile, nil)
 	if err != nil {
 		return nil, err
@@ -485,7 +555,7 @@ func (p *Postgres) SelectTemperatures(ctx context.Context) ([]*types.MeasuredVal
 }
 
 func (p *Postgres) SelectTemperatureByID(ctx context.Context, id string) (*types.MeasuredValue, error) {
-	queryFile := "pkg/db/sql/psql/selectTemperatureByID.sql"
+	queryFile := fmt.Sprintf("%v/selectTemperatureByID.sql", postgresAssetPath)
 	args := []interface{}{id}
 	measuredValues, err := p.selectMeasuredValues(ctx, types.MeasuredValueTypeTemperature, queryFile, args)
 	if err != nil {
@@ -531,6 +601,28 @@ func (p *Postgres) UpdateDevices(ctx context.Context, devices []*types.Device) e
 	return nil
 }
 
+func (p *Postgres) UpdateInfo(ctx context.Context, key string, value string) error {
+	asset := fmt.Sprintf("%v/updateInfo.sql", postgresAssetPath)
+	queryBytes, err := Asset(asset)
+	if err != nil {
+		return fmt.Errorf("%v: %v", errorGetAsset, err)
+	}
+	query := string(queryBytes)
+
+	stmt, err := p.dbo.PrepareContext(ctx, query)
+	if err != nil {
+		return fmt.Errorf("%v: %v", errorPrepareStatement, err)
+	}
+	defer stmt.Close()
+
+	_, err = stmt.ExecContext(ctx, key, value)
+	if err != nil {
+		return fmt.Errorf("%v: %v", errorStatementExecute, err)
+	}
+
+	return nil
+}
+
 func (p *Postgres) UpdateMeasuredValues(ctx context.Context, measuredValues []*types.MeasuredValue) error {
 	return nil
 }
@@ -538,42 +630,3 @@ func (p *Postgres) UpdateMeasuredValues(ctx context.Context, measuredValues []*t
 func (p *Postgres) UpdateSensors(ctx context.Context, sensots []*types.Sensor) error {
 	return nil
 }
-
-func schema(fromVersion *semver.Version, toVersion *semver.Version) error {
-
-	sqlAssetFiles, err := parseAssetDir("pkg/db/sql/psql/schema")
-	if err != nil {
-		return fmt.Errorf("Can not restore sql files: %v", err)
-	}
-
-	for _, sqlAssetFile := range sqlAssetFiles {
-
-    version := strings.Replace()
-
-		sqlSchemaInformations := &schemaInformation{
-			Version: filepath.Split()
-			Asset:   sqlAssetFile,
-		}
-
-	}
-
-	return nil
-}
-
-func parseAssetDir(dir string) ([]string, error) {
-	assetFiles, err := AssetDir(dir)
-	if err != nil {
-		return nil, fmt.Errorf("Can not load asset directory %v: %v", dir, err)
-	}
-
-	goldenAssetFiles := assetFiles
-
-	for i, assetFile := range assetFiles {
-		if strings.HasPrefix(assetFile, "/") {
-			// is directory- SKIP
-			goldenAssetFiles = append(goldenAssetFiles[:i], goldenAssetFiles[i+1:]...)
-		}
-	}
-
-	return goldenAssetFiles, nil
-}

pkg/storage/db/postgres_test.go

@@ -2,9 +2,12 @@ package db_test
 
 import (
 	"context"
+	"strings"
 	"testing"
 
-	"github.com/go-flucky/flucky/pkg/db"
+	"github.com/Masterminds/semver"
+	"github.com/go-flucky/flucky/pkg/config"
+	"github.com/go-flucky/flucky/pkg/storage/db"
 	"github.com/go-flucky/flucky/pkg/types"
 	"github.com/go-flucky/flucky/test/goldenfiles"
 	"github.com/stretchr/testify/require"
@@ -19,11 +22,15 @@ var (
 	database db.Database
 
 	postgresContainerImage string = "docker.io/postgres/postgres"
-	postgresHost           string = "localhost"
-	postgresPort           string = "5432"
-	postgresUser           string = "postgres"
-	postgresPassword       string = "postgres"
-	postgresDatabase       string = "postgres"
+
+	postgresSettings = &config.DatabaseSettings{
+		Vendor:   config.VendorPostgreSQL,
+		Host:     "localhost",
+		Port:     "5432",
+		User:     "postgres",
+		Password: "postgres",
+		Database: "postgres",
+	}
 
 	goldenDevicesFilePath        string = "test/goldenfiles/json/goldenDevices.json"
 	goldenSensorsFilePath        string = "test/goldenfiles/json/goldenSensors.json"
@@ -74,7 +81,7 @@ func TestPostgres(t *testing.T) {
 
 	load(t)
 
-	db, err := db.New(db.DBOTypePostgres, postgresHost, postgresPort, postgresDatabase, postgresUser, postgresPassword)
+	db, err := db.New(postgresSettings)
 	database = db
 	require.Nil(err)
 
@@ -83,54 +90,54 @@ func TestPostgres(t *testing.T) {
 			Name: "schema",
 			Test: testSchemaCreate,
 		},
-		// &test{
-		// 	Name: "insertDevices",
-		// 	Test: testInsertDevices,
-		// },
-		// &test{
-		// 	Name: "insertSensors",
-		// 	Test: testInsertSensors,
-		// },
-		// &test{
-		// 	Name: "insertHumidity",
-		// 	Test: testInsertHumidity,
-		// },
-		// &test{
-		// 	Name: "insertPressure",
-		// 	Test: testInsertPressure,
-		// },
-		// &test{
-		// 	Name: "insertTemperatures",
-		// 	Test: testInsertTemperatures,
-		// },
-		// &test{
-		// 	Name: "deleteHumidities",
-		// 	Test: testDeleteHumidity,
-		// },
-		// &test{
-		// 	Name: "deletePressures",
-		// 	Test: testDeletePressures,
-		// },
-		// &test{
-		// 	Name: "deleteTemperatures",
-		// 	Test: testDeleteTemperatures,
-		// },
-		// &test{
-		// 	Name: "insertMeasuredValues",
-		// 	Test: testInsertMeasuredValues,
-		// },
-		// &test{
-		// 	Name: "deleteMeasuredValues",
-		// 	Test: testDeleteMeasuredValues,
-		// },
-		// &test{
-		// 	Name: "deleteSensors",
-		// 	Test: testDeleteSensors,
-		// },
-		// &test{
-		// 	Name: "deleteDevices",
-		// 	Test: testDeleteDevices,
-		// },
+		&test{
+			Name: "insertDevices",
+			Test: testInsertDevices,
+		},
+		&test{
+			Name: "insertSensors",
+			Test: testInsertSensors,
+		},
+		&test{
+			Name: "insertHumidity",
+			Test: testInsertHumidity,
+		},
+		&test{
+			Name: "insertPressure",
+			Test: testInsertPressure,
+		},
+		&test{
+			Name: "insertTemperatures",
+			Test: testInsertTemperatures,
+		},
+		&test{
+			Name: "deleteHumidities",
+			Test: testDeleteHumidity,
+		},
+		&test{
+			Name: "deletePressures",
+			Test: testDeletePressures,
+		},
+		&test{
+			Name: "deleteTemperatures",
+			Test: testDeleteTemperatures,
+		},
+		&test{
+			Name: "insertMeasuredValues",
+			Test: testInsertMeasuredValues,
+		},
+		&test{
+			Name: "deleteMeasuredValues",
+			Test: testDeleteMeasuredValues,
+		},
+		&test{
+			Name: "deleteSensors",
+			Test: testDeleteSensors,
+		},
+		&test{
+			Name: "deleteDevices",
+			Test: testDeleteDevices,
+		},
 	}
 
 	for _, test := range tests {
@@ -140,9 +147,18 @@ func TestPostgres(t *testing.T) {
 
 func testSchemaCreate(t *testing.T) {
 	require := require.New(t)
-	ctx := context.Background()
-	err := database.Schema(ctx, "v0.1.0")
+
+	homePath := "pkg/storage/db/sql/psql/schema"
+	sqlAssetFiles, err := db.AssetDir(homePath)
 	require.NoError(err)
+
+	ctx := context.Background()
+	for _, sqlAssetFile := range sqlAssetFiles {
+		fromVersion, err := semver.NewVersion(strings.ReplaceAll(sqlAssetFile, ".sql", ""))
+		require.NoError(err)
+		err = database.Schema(ctx, fromVersion)
+		require.NoError(err)
+	}
 }
 
 func testInsertDevices(t *testing.T) {

pkg/storage/db/sql/psql/insertInfo.sql

@@ -0,0 +1,2 @@
+INSERT INTO info (key, value)
+VALUES ($1, $2);

pkg/storage/db/sql/psql/selectInfo.sql

@@ -0,0 +1,3 @@
+SELECT value
+FROM info
+WHERE key = $1;

pkg/storage/db/sql/psql/updateInfo.sql

@@ -0,0 +1,3 @@
+UPDATE info
+SET value = $2
+WHERE key = $1;

pkg/types/device.go

@@ -8,6 +8,5 @@ type Device struct {
 	DeviceName        string     `json:"device_name" xml:"device_name"`
 	DeviceLocation    *string    `json:"device_location" xml:"device_location"`
 	DeviceLastContact *time.Time `json:"device_last_contact" xml:"device_last_contact"`
-	Logfile           string     `json:"logfile" xml:"logfile"`
 	CreationDate      time.Time  `json:"creation_date" xml:"creation_date"`
 }