ErrorHandler is the protocol for handling errors, use this to implement
custom error handling logic.
NoErrorHandler is a default error handler that does nothing, useful when
you don't need to handle errors.
{
return nil
}ErrorHandlerFn is an error handler that implements the ErrorHandler
protocol, use this to create custom error handling logic.
func(args ...interface{}) error
CleanupQueue is a priority queue that runs cleanup tasks in order of
priority and uses the defined error handler to handle errors.
Add adds a new task to the cleanup queue.
{
cleanupTask := &CleanupTask{
Task: task,
Args: args,
Priority: priority,
ErrorHandler: errorHandler,
IgnoreErrorHandlerFailure: ignoreErrorHandlerFailure,
}
heap.Push(&q.tasks, cleanupTask)
}Run runs the cleanup queue and executes all the tasks in order of priority.
It returns an error if any of the tasks encounter an error, including the
error handler function, unless the task is marked to ignore error handler
failures.
{
for q.tasks.Len() > 0 {
task := heap.Pop(&q.tasks).(*CleanupTask)
err := task.Task(task.Args...)
if err != nil {
errHandle := task.ErrorHandler.HandleError(task.Args...)
if errHandle != nil {
if !task.IgnoreErrorHandlerFailure {
return fmt.Errorf("error handling failed: %v", errHandle)
}
}
}
}
return nil
}NewCleanupQueue creates a new cleanup queue.
{
q := &CleanupQueue{}
heap.Init(&q.tasks)
return q
}CleanupTask is a task that defines a cleanup task to be run in the cleanup
queue. It has a priority, a task to run, a list of arguments, an error
handler to handle errors, and a flag to ignore error handler failures.
[]*CleanupTask
EventManager is a simple event manager that allows subscribing to events
and notifying them, so that multiple parts of the code can be notified
when an event happens and act accordingly.
Subscribe subscribes to an event type and returns a subscription ID, use
this ID to unsubscribe from the event later.
subID := eventManager.Subscribe("testEvent", func(data interface{}) {
fmt.Println("Event happened:", data)
})
fmt.Println("Subscribed with ID:", subID)
{
em.mu.Lock()
defer em.mu.Unlock()
if em.listeners[eventType] == nil {
em.listeners[eventType] = make(map[int]EventHandler)
}
em.nextID++
id := em.nextID
em.listeners[eventType][id] = handler
return id
}Unsubscribe unsubscribes from an event type using its subscription ID
subID := eventManager.Subscribe("testEvent", func(data interface{}) {
fmt.Println("Event happened:", data)
})
fmt.Println("Subscribed with ID:", subID)
eventManager.Unsubscribe("testEvent", subID)
{
em.mu.Lock()
defer em.mu.Unlock()
if handlers, ok := em.listeners[eventType]; ok {
delete(handlers, id)
}
}Notify notifies an event type with some data, all the handlers subscribed
to the event type will be called with the data.
eventManager.Notify("testEvent", "testData")
{
em.mu.RLock()
defer em.mu.RUnlock()
if handlers, ok := em.listeners[eventType]; ok {
for _, handler := range handlers {
handler(data)
}
}
}EventHandler is the protocol for handling events, use this to implement
custom event handling logics for your application.
func(interface{})
NewEventManager creates a new event manager.
eventManager := goodies.NewEventManager()
eventManager.Subscribe("testEvent", func(data interface{}) {
fmt.Println("Event happened:", data)
})
eventManager.Notify("testEvent", "testData")
{
return &EventManager{
listeners: make(map[string]map[int]EventHandler),
}
}ValidatorType defines the protocol for a validation method. Implement this
to create custom validation methods for your integrity checks.
SHA1Validator is an implementation of the validation method using SHA-1
{
h := sha1.New()
if _, err := io.Copy(h, data); err != nil {
return "", err
}
return hex.EncodeToString(h.Sum(nil)), nil
}SHA256Validator is an implementation of the validation method using SHA-256
{
h := sha256.New()
if _, err := io.Copy(h, data); err != nil {
return "", err
}
return hex.EncodeToString(h.Sum(nil)), nil
}MD5Validator is an implementation of the validation method using MD5
{
h := md5.New()
if _, err := io.Copy(h, data); err != nil {
return "", err
}
return hex.EncodeToString(h.Sum(nil)), nil
}IntegrityCheckResult represents the result of an integrity check
FailedCheck represents a failed integrity check
CheckIntegrity performs an integrity check of the provided data using the
provided validation method and returns the result. If a validation fails
the result will contain the failed checks.
The prefix parameter specifies the base path to be used for each file check.
data := []byte("batman.txt 8c555f537cd1fe3f1239ebf7b6d639bc0d576bda\nrobin.txt 4e58c66d2ef2b9a60c7ea2bc03253d8b01874b52")
result, err := CheckIntegrity(data, SHA1Validator{}, "files/")
if err != nil {
fmt.Printf("Error: %v\n", err)
}
fmt.Printf("Total requested: %d\n", result.TotalRequested)
fmt.Printf("Passed: %d\n", result.Passed)
fmt.Printf("Failed: %d\n", result.Failed)
for _, failedCheck := range result.FailedChecks {
fmt.Printf("Resource: %s\n", failedCheck.ResourcePath)
fmt.Printf("Requested: %s\n", failedCheck.RequestedHash)
fmt.Printf("Detected: %s\n", failedCheck.DetectedHash)
}
{
pairings := make(map[string]string)
lines := strings.Split(string(data), "\n")
for _, line := range lines {
parts := strings.SplitN(line, " ", 2)
if len(parts) != 2 {
return IntegrityCheckResult{}, fmt.Errorf("invalid line format: %s", line)
}
pairings[parts[0]] = parts[1]
}
// Perform the integrity check using the provided validation method
return checkIntegrity(pairings, method, prefix)
}checkIntegrity performs the integrity check of the file data using
the provided validation method.
{
var result IntegrityCheckResult
for resourcePath, requestedHash := range pairings {
// If a prefix is provided, we have to join it with the resource path to
// ensure the file is found in the place the developer expects.
fullPath := filepath.Join(prefix, resourcePath)
detectedHash, err := calculateHash(fullPath, method)
if err != nil {
fmt.Printf("Error calculating hash for %s: %v\n", fullPath, err)
continue
}
result.TotalRequested++
if requestedHash == detectedHash {
result.Passed++
} else {
result.Failed++
result.FailedChecks = append(result.FailedChecks, FailedCheck{
ResourcePath: fullPath,
RequestedHash: requestedHash,
DetectedHash: detectedHash,
})
}
}
return result, nil
}calculateHash calculates the hash of a file using the provided validation
method and returns it as a string.
{
file, err := os.Open(filePath)
if err != nil {
return "", err
}
defer file.Close()
return method.Hash(file)
}import "container/heap"import "fmt"import "sync"import "crypto/md5"import "crypto/sha1"import "crypto/sha256"import "encoding/hex"import "fmt"import "io"import "os"import "path/filepath"import "strings"