Refactor (#1)

* refactor

* tidy go mod

* Add stubs

* Update readme

Author: x1unix

README.md

@@ -0,0 +1,10 @@
+# go-regwatch
+
+Package regwatch provides a tiny wrapper that allows to track registry key changes
+in Windows operating system.
+
+This library wraps `RegNotifyChangeKeyValue` Windows syscall.
+
+## Usage
+
+See `example_test.go`

example_test.go

@@ -0,0 +1,112 @@
+package regwatch
+
+import (
+	"fmt"
+	"sync"
+	"os"
+	"os/signal"
+	"context"
+	"runtime"
+	"testing"
+	"time"
+)
+
+const keyPath = `SOFTWARE\SAAZOD\ManagedPosix`
+
+func TestExample(t *testing.T) {
+	runtime.LockOSThread()
+	runtime.GOMAXPROCS(runtime.NumCPU())
+	ctx, cancelFn := cancelHandler()
+	wg := &sync.WaitGroup{}
+	wg.Add(2)
+	w, err := NewWatcher(HKeyLocalMachine, keyPath, 1000)
+	must(err)
+
+	go func() {
+		<-time.After(5 * time.Second)
+		fmt.Printf("INFO:\tstopping...\n")
+		cancelFn()
+		os.Exit(1)
+	}()
+
+	updates := make(chan string)
+	go func() {
+		fmt.Printf("INFO:\tconsumer: start...\n")
+		for {
+			kp, ok := <-updates
+			if !ok {
+				fmt.Printf("INFO:\tconsumer: shutdown...\n")
+				return
+			}
+
+			fmt.Printf("INFO:\t consumer: Received update msg - '%s'\n", kp)
+		}
+	}()
+
+	go func() {
+		fmt.Printf("INFO:\tLooking for changes in '%s'...\n", keyPath)
+		defer func() {
+			if err := w.Destroy(); err != nil {
+				fmt.Printf("ERROR:\tWatcher.Destroy - %s\n", err)
+			}
+
+			close(updates)
+			wg.Done();
+		}()
+
+		for {
+			select {
+			case <-ctx.Done():
+				fmt.Printf("INFO:\tGot shutdown signal...\n")
+				return
+			default:
+			}
+
+			changed, err := w.Await()
+			if err != nil {
+				fmt.Printf("ERROR:\tWatcher.Await - %s\n", err)
+				return
+			}
+
+			if !changed {
+				continue
+			}
+
+			fmt.Printf("INFO:\t'%s' changed\n", keyPath)
+			updates <- keyPath
+		}
+	}()
+
+
+	fmt.Println("Waiting...")
+	wg.Wait()
+	fmt.Println("Goodbye")
+}
+
+// cancelHandler returns cancellation context and function for graceful shutdown
+func cancelHandler() (context.Context, context.CancelFunc) {
+	ctx, cancelFn := context.WithCancel(context.Background())
+
+	signals := make(chan os.Signal, 1)
+	signal.Notify(signals, os.Interrupt)
+
+	go func() {
+		<-signals
+		cancelFn()
+		signal.Stop(signals)
+	}()
+
+	return ctx, cancelFn
+}
+
+func must(err error) {
+	if err != nil {
+		panic(err)
+	}
+}
+
+func try(err error) {
+	if err != nil {
+		_, _ = fmt.Fprintf(os.Stderr, "ERR: %s\n", err)
+	}
+}

funcs.go

@@ -1,3 +1,3 @@
-module regwatch
+module github.com/x1unix/go-regwatch
 
-go 1.12
+go 1.11

go.mod

@@ -4,61 +4,60 @@
 #include <tchar.h>
 #include <stdio.h>
 
-boolean reg_global_listener(char* regPath, long lEvent);
-
 const DWORD dwFilter = REG_NOTIFY_CHANGE_NAME |
                        REG_NOTIFY_CHANGE_ATTRIBUTES |
                        REG_NOTIFY_CHANGE_LAST_SET |
                        REG_NOTIFY_CHANGE_SECURITY;
 
-typedef struct Watcher {
-	HKEY hKey;
-	HANDLE hEvent;
-} Watcher;
 
-long reg_add_listener(callback cb, HKEY hMainKey, char* regPath) {
+#define HANDLE_ERR(val) if (val != ERROR_SUCCESS) return val
+
+long watcher_create(void* hive, char* regPath, Watcher* out) {
+	HKEY hMainKey = (HKEY) hive;
 	HKEY hKey;
 
 	DEBUG_PRINT("RegOpenKeyEx '%s'\n", regPath);
 	LONG lErrorCode = RegOpenKeyEx(hMainKey, regPath, 0, KEY_NOTIFY, &hKey);
-	if (lErrorCode != ERROR_SUCCESS) 
-		return lErrorCode;
+	HANDLE_ERR(lErrorCode);
 
 	DEBUG_PRINT("CreateEvent\n");
 	HANDLE hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 	if (hEvent == NULL) 
 		return GetLastError();
 
-	while(TRUE) {
-		DEBUG_PRINT("RegNotifyChangeKeyValue\n");
-		lErrorCode = RegNotifyChangeKeyValue(hKey, TRUE, dwFilter, hEvent, TRUE);
-		if(lErrorCode != ERROR_SUCCESS) break;
-
-		DEBUG_PRINT("WaitForSingleObject\n");
-		DWORD dwEvent = WaitForSingleObject(hEvent, INFINITE);
-		ResetEvent(hEvent);
-		if (dwEvent == WAIT_OBJECT_0) {
-			boolean result = cb(regPath, dwEvent);
-			DEBUG_PRINT("Callback returned %d\n", result);
-			if (!result) {
-				DEBUG_PRINT("break\n");
-				break;
-			}
-			continue;
-		}
+	out->hKey = hKey;
+	out->hEvent = hEvent;
+	return 0;
+}
 
-		lErrorCode = dwEvent;
-		break;
+long watcher_await(Watcher* out, long timeout, boolean* changed) {
+	LONG lErrorCode;
+	DEBUG_PRINT("RegNotifyChangeKeyValue\n");
+	lErrorCode = RegNotifyChangeKeyValue(out->hKey, TRUE, dwFilter, out->hEvent, TRUE);
+	HANDLE_ERR(lErrorCode);
+	DEBUG_PRINT("WaitForSingleObject\n");
+	DWORD dwEvent = WaitForSingleObject(out->hEvent, timeout);
+	ResetEvent(out->hEvent);
+	switch (dwEvent) {
+		case WAIT_TIMEOUT:
+			*changed = FALSE;
+			break;
+		case WAIT_OBJECT_0:
+			*changed = TRUE;
+			break;
+		default:
+			return dwEvent; 
 	}
-	
-	DEBUG_PRINT("Close watcher\n");
-	RegCloseKey(hKey);
-	CloseHandle(hEvent);
-	free(regPath);	// Allocated in heap by C.GoString()
-	return lErrorCode;
+
+	return 0;
 }
 
-long reg_listen(HKEY hMainKey, char* regPath) {
-  return reg_add_listener(reg_global_listener, hMainKey, regPath);
+long watcher_close(Watcher* out) {
+	DEBUG_PRINT("RegCloseKey\n");
+	LONG lErrorCode = RegCloseKey(out->hKey);
+	HANDLE_ERR(lErrorCode);
+	DEBUG_PRINT("CloseHandle\n");
+	CloseHandle(out->hEvent);
 }
+
 #endif

go.sum

@@ -1,7 +1,6 @@
 #ifndef WATCH_H
 #define WATCH_H
 
-#define DEBUG 3
 #include <windows.h>
 #include <stdlib.h>
 
@@ -13,10 +12,12 @@
  #define DEBUG_PRINT(fmt, ...) /* Don't do anything in release builds */
 #endif
 
+typedef struct Watcher {
+	HKEY hKey;
+	HANDLE hEvent;
+} Watcher;
 
-typedef boolean (*callback)(char*, long);
-
-long reg_add_listener(callback cb, HKEY hMainKey, char* regPath);
-long reg_listen(HKEY hMainKey, char* regPath);
-
+long watcher_create(void* hive, char* regPath, Watcher* out);
+long watcher_await(Watcher* out, long timeout, boolean* changed);
+long watcher_close(Watcher* out);
 #endif

main.go

@@ -0,0 +1,18 @@
+// Package regwatch provides a tiny wrapper that allows to track registry key changes
+// in Windows operating system.
+//
+// See "example_test.go" for usage example.
+package regwatch
+
+// Timeout represents event timeout in milliseconds
+type Timeout uint32
+
+
+// Watcher tracks registry changes
+type Watcher interface {
+	// Destroy stops
+	Destroy() error
+
+	// Await waits until key change event occurs
+	Await() (bool, error)
+}