Merge lp:~kyrofa/go-ual/observers_collection into lp:go-ual

[Kyle Fazzari]

Add an Go-side observer tracker.

Add an Go-side observer tracker.

This is necessary due to Go's inability to pack functions into C function pointers, so we'll have to make gateway functions for them and track the Go side ourselves.

[lp:~kyrofa/go-ual/observers_collection]

2. By Kyle Fazzari on 2015-09-17

Implement bindings for various UAL helper methods.

Specifically, GetPrimaryPid(), StartSessionHelper()
and StopMultipleHelper().

Signed-off-by: Kyle Fazzari <email address hidden>

3. By Kyle Fazzari on 2015-09-17

Restrict the license header to version 3 of the GPL.

Signed-off-by: Kyle Fazzari <email address hidden>

4. By Kyle Fazzari on 2015-09-17

Change license to LGPLv3.

Signed-off-by: Kyle Fazzari <email address hidden>

5. By Kyle Fazzari on 2015-09-17

Add an Go-side observer tracker.

This is necessary due to Go's inability to pack functions into
C function pointers, so we'll have to make gateway functions
for them and track the Go side ourselves.

Signed-off-by: Kyle Fazzari <email address hidden>

6. By Kyle Fazzari on 2015-09-17

Restrict the license headers to version 3 of the GPL.

Signed-off-by: Kyle Fazzari <email address hidden>

7. By Kyle Fazzari on 2015-09-17

Change license to LGPLv3.

Signed-off-by: Kyle Fazzari <email address hidden>

[dobey (dobey)]

review: Approve

=== added file 'ual/observers_collection.go'
--- ual/observers_collection.go	1970-01-01 00:00:00 +0000
+++ ual/observers_collection.go	2015-09-17 18:06:40 +0000
@@ -0,0 +1,114 @@
+/* Copyright (C) 2015 Canonical Ltd.
+ *
+ * This file is part of go-ual.
+ *
+ * go-ual is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License version 3, as published by the
+ * Free Software Foundation.
+ *
+ * go-ual is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with go-ual. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package ual
+
+import (
+	"fmt"
+	"sync"
+	"unsafe"
+)
+
+type Observer func(string, string, string)
+type ObserverId int
+
+// ObserversCollection is responsible for tracking observers for a given event.
+// It exists for two reasons. First of all, we can't pass Go functions into C.
+// Second, if we packed the function into the UAL `user_data` Go would lose
+// track of it and it'd be garbage-collected. ObserversCollection can safely be
+// accessed simultaneously from multiple threads.
+type ObserversCollection struct {
+	mutex      sync.RWMutex
+	observers  map[ObserverId]observerAndHelperType
+	observerId ObserverId
+}
+
+// observerAndHelperType associates an observer and a helper type.
+type observerAndHelperType struct {
+	observerPointer unsafe.Pointer
+	helperType      string
+}
+
+// AddObserver adds an observer to the collection and returns a unique ID for
+// it. This ID is used for all further ObserversCollection communication for
+// that observer (e.g. calling the observer, removing it, etc.). It also
+// returns an unsafe.Pointer for the observer which can be passed into C.
+func (collection *ObserversCollection) AddObserver(helperType string,
+	observer Observer) ObserverId {
+	collection.mutex.Lock()
+	defer collection.mutex.Unlock()
+
+	if collection.observers == nil {
+		collection.observers = make(map[ObserverId]observerAndHelperType)
+	}
+
+	collection.observerId += 1
+
+	collection.observers[collection.observerId] = observerAndHelperType{
+		observerPointer: unsafe.Pointer(&observer),
+		helperType:      helperType,
+	}
+
+	return collection.observerId
+}
+
+// RemoveObserver removes the observer represented by the given ID from the
+// collection.
+func (collection *ObserversCollection) RemoveObserver(id ObserverId) bool {
+	collection.mutex.Lock()
+	defer collection.mutex.Unlock()
+
+	// Reading from a potentially nil map is okay-- it will behave as if it was
+	// empty.
+	_, ok := collection.observers[id]
+	if ok {
+		delete(collection.observers, id)
+		return true
+	}
+
+	return false
+}
+
+// Observer returns the unsafe.Pointer for a given observer.
+func (collection *ObserversCollection) Observer(id ObserverId) (unsafe.Pointer, error) {
+	collection.mutex.RLock()
+	defer collection.mutex.RUnlock()
+
+	// Reading from a potentially nil map is okay-- it will behave as if it was
+	// empty.
+	observerAndHelper, ok := collection.observers[id]
+	if ok {
+		return observerAndHelper.observerPointer, nil
+	}
+
+	return nil, fmt.Errorf("No observer with ID %d", id)
+}
+
+// ObserverHelperType returns the helper type for a given observer.
+func (collection *ObserversCollection) ObserverHelperType(id ObserverId) (string, error) {
+	collection.mutex.RLock()
+	defer collection.mutex.RUnlock()
+
+	// Reading from a potentially nil map is okay-- it will behave as if it was
+	// empty.
+	observerAndHelper, ok := collection.observers[id]
+	if ok {
+		return observerAndHelper.helperType, nil
+	}
+
+	return "", fmt.Errorf("No observer with ID %d", id)
+}

=== added file 'ual/observers_collection_test.go'
--- ual/observers_collection_test.go	1970-01-01 00:00:00 +0000
+++ ual/observers_collection_test.go	2015-09-17 18:06:40 +0000
@@ -0,0 +1,75 @@
+/* Copyright (C) 2015 Canonical Ltd.
+ *
+ * This file is part of go-ual.
+ *
+ * go-ual is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License version 3, as published by the
+ * Free Software Foundation.
+ *
+ * go-ual is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with go-ual. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package ual
+
+import (
+	"testing"
+)
+
+// Test typical observer usage: add, call and delete
+func TestObserversCollection(t *testing.T) {
+	collection := ObserversCollection{}
+
+	if len(collection.observers) > 0 {
+		t.Errorf("Observers collection has %d observers, expected it to be empty",
+			len(collection.observers))
+	}
+
+	called := false
+	id := collection.AddObserver("foo", func(a, b, c string) {
+		called = true
+	})
+
+	if len(collection.observers) != 1 {
+		t.Errorf("Observers collection has %d observers, expected 1",
+			len(collection.observers))
+	}
+
+	helperType, err := collection.ObserverHelperType(id)
+	if helperType != "foo" {
+		t.Errorf(`Helper type was "%s", expected "foo"`, helperType)
+	}
+
+	observerPointer, err := collection.Observer(id)
+	if err != nil {
+		t.Errorf("Unexpected error obtaining observer: %s", err)
+	}
+
+	(*(*Observer)(observerPointer))("foo", "bar", "baz")
+
+	if !called {
+		t.Errorf("Expected observer to be called")
+	}
+
+	if !collection.RemoveObserver(id) {
+		t.Error("Unexpected error removing observer")
+	}
+
+	if len(collection.observers) > 0 {
+		t.Errorf("Observers collection has %d observers, expected it to be empty",
+			len(collection.observers))
+	}
+
+	called = false
+	// Should still be able to call the observer
+	(*(*Observer)(observerPointer))("foo", "bar", "baz")
+
+	if !called {
+		t.Errorf("Expected observer to be called")
+	}
+}