Query versioning support

.github/workflows/create-release.yml

@@ -28,8 +28,13 @@ jobs:
       - name: Display Go version
         run: go version
 
+      - name: Start MongoDB
+        uses: supercharge/[email protected]
+        with:
+          mongodb-version: '8.0'
+
       - name: Run tests
-        run: go test
+        run: go test ./...
 
       - name: Run GoReleaser
         uses: goreleaser/goreleaser-action@v6

.github/workflows/run-tests.yml

@@ -28,5 +28,10 @@ jobs:
       - name: Display Go version
         run: go version
 
+      - name: Start MongoDB
+        uses: supercharge/[email protected]
+        with:
+          mongodb-version: '8.0'
+
       - name: Run tests
-        run: go test
+        run: go test ./...

README.md

@@ -7,7 +7,7 @@ Application written in Go to collect the information from webpages or API endpoi
 ## Prerequisites
 
 - Tested with Go 1.23.2
-- [MongoDB](https://www.mongodb.com/docs/manual/administration/install-community/)
+- [MongoDB 8.0](https://www.mongodb.com/docs/manual/administration/install-community/)
 
 ## Installation
 

autoini/autoini.go

@@ -92,6 +92,8 @@ func ReadIni[T Configurable](path string) (result T) {
 			setStringKey(result, fieldName, reflect.Indirect(configReflection).Field(i), cfg)
 		case "int":
 			setIntKey(result, fieldName, reflect.Indirect(configReflection).Field(i), cfg)
+		case "int64":
+			setIntKey(result, fieldName, reflect.Indirect(configReflection).Field(i), cfg)
 		case "bool":
 			setBoolKey(result, fieldName, reflect.Indirect(configReflection).Field(i), cfg)
 		default:

hash.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"io"
+	"os"
+)
+
+func GetFileHash(path string) (hash string, err error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return
+	}
+	defer file.Close()
+
+	var hashFunction = sha256.New()
+	_, err = io.Copy(hashFunction, file)
+	if err != nil {
+		return
+	}
+
+	hash = fmt.Sprintf("%x", hashFunction.Sum(nil))
+	return
+}

hash_test.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGetFileHashValid(t *testing.T) {
+	var assert = assert.New(t)
+
+	var hash, err = GetFileHash("hash_test.go")
+	assert.Equal(nil, err, "Returned an error 1")
+	assert.Equal(64, len(hash), "Incorrect hash length 1")
+
+	hash, err = GetFileHash("test/example.txt")
+	assert.Equal(nil, err, "Returned an error 2")
+	assert.Equal("a9a66978f378456c818fb8a3e7c6ad3d2c83e62724ccbdea7b36253fb8df5edd", hash, "Incorrect hash length 2")
+}
+
+func TestGetFileHashInvalid(t *testing.T) {
+	var assert = assert.New(t)
+
+	var _, err = GetFileHash("invalid.exe")
+	assert.NotEqual(nil, err, "Did not return an error 1")
+}

main.go

@@ -22,15 +22,15 @@ func main() {
 	defer mongo.Disconnect()
 
 	// Create the default versions collection
-	err = mongo.CreateCollection("versions")
+	err = mongo.CreateCollection(config.VersionCollectionName)
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	var dir = "./queries"
 	var stopRequest = make(chan any)
 	var stopResponse = make(chan any)
-	err = StartTrackers(ListIniFiles(dir), mongo, stopRequest, stopResponse)
+	err = StartTrackers(ListIniFiles(dir), config, mongo, stopRequest, stopResponse)
 	if err != nil {
 		log.Fatal(err)
 	}

mongodb/mongodb.go

@@ -2,6 +2,7 @@ package mongodb
 
 import (
 	"context"
+	"errors"
 	"time"
 
 	"go.mongodb.org/mongo-driver/v2/bson"
@@ -10,6 +11,15 @@ import (
 	"go.mongodb.org/mongo-driver/v2/mongo/readpref"
 )
 
+func BsonToRaw(value bson.D) (document bson.Raw, err error) {
+	doc, err := bson.Marshal(value)
+	if err != nil {
+		return document, err
+	}
+	err = bson.Unmarshal(doc, &document)
+	return
+}
+
 type MongoDB struct {
 	client   *mongo.Client
 	database *mongo.Database
@@ -34,24 +44,30 @@ func NewMongoDB(uri string, databaseName string) (result MongoDB, err error) {
 	return result, err
 }
 
-func Connect(uri string) (client *mongo.Client, err error) {
-	return mongo.Connect(options.Client().ApplyURI(uri))
-}
+func (m *MongoDB) Disconnect() error {
+	if m.client == nil {
+		return errors.New("client is nil")
+	}
 
-func (m *MongoDB) Disconnect() {
 	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
 	defer cancel()
 
 	if err := m.client.Disconnect(ctx); err != nil {
 		panic(err)
 	}
+
+	return nil
 }
 
 func (m *MongoDB) CreateCollection(collection string) (err error) {
+	if m.database == nil {
+		return errors.New("database is nil")
+	}
+
 	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
 	defer cancel()
-	// Ensure that we create only missing collection
-	names, err := m.database.ListCollectionNames(ctx, bson.D{{"name", collection}})
+	// Ensure that we create only a missing collection
+	names, err := m.database.ListCollectionNames(ctx, bson.D{{Key: "name", Value: collection}})
 	if err != nil {
 		return err
 	}
@@ -64,6 +80,10 @@ func (m *MongoDB) CreateCollection(collection string) (err error) {
 }
 
 func (m *MongoDB) Write(collection string, data bson.D) (err error) {
+	if m.database == nil {
+		return errors.New("database is nil")
+	}
+
 	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
 	defer cancel()
 	mongoCollection := m.database.Collection(collection)
@@ -72,26 +92,39 @@ func (m *MongoDB) Write(collection string, data bson.D) (err error) {
 	return err
 }
 
-func (m *MongoDB) GetLastDocument(collection string, sortedKey string) (result bson.D, err error) {
+func (m *MongoDB) GetLastDocumentFiltered(collection string, sortedKey string, filter bson.D) (result bson.D, err error) {
+	if m.database == nil {
+		return result, errors.New("database is nil")
+	}
+
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
 
 	mongoCollection := m.database.Collection(collection)
-	count, err := mongoCollection.CountDocuments(ctx, bson.D{})
+	count, err := mongoCollection.CountDocuments(ctx, filter)
 	if err != nil || count == 0 {
 		return result, err
 	}
-	opts := options.FindOne().SetSort(bson.D{{sortedKey, 1}}).SetSkip(count - 1)
+	opts := options.FindOne().SetSort(bson.D{{Key: sortedKey, Value: 1}}).SetSkip(count - 1)
 
-	err = mongoCollection.FindOne(ctx, bson.D{}, opts).Decode(&result)
+	// TODO: Return un-decoded result
+	err = mongoCollection.FindOne(ctx, filter, opts).Decode(&result)
 	if err != nil {
 		return result, err
 	}
 
 	return
 }
 
+func (m *MongoDB) GetLastDocument(collection string, sortedKey string) (result bson.D, err error) {
+	return m.GetLastDocumentFiltered(collection, sortedKey, bson.D{})
+}
+
 func (m *MongoDB) GetAllDocuments(collection string) (result []bson.D, err error) {
+	if m.database == nil {
+		return result, errors.New("database is nil")
+	}
+
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
 
@@ -116,3 +149,16 @@ func (m *MongoDB) GetAllDocuments(collection string) (result []bson.D, err error
 
 	return
 }
+
+func (m *MongoDB) DropCollection(collection string) (err error) {
+	if m.database == nil {
+		return errors.New("database is nil")
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	mongoCollection := m.database.Collection(collection)
+	err = mongoCollection.Drop(ctx)
+	return
+}