Merge lp:~sergiusens/ciborium/inital_implementation into lp:ciborium

[Sergio Schvezov]

Golang setup:

sudo apt install golang-go
# export GOPATH; e.g.;
export GOPATH=~/go

mkdir -p $GOPATH/src/launchpad.net
cd $GOPATH/src/launchpad.net
bzr branch lp:~sergiusens/ciborium/initial_implementation ciborium

To test on desktop:
go build launchpad.net/ciborium/cmd/ciborium
# go get missing deps and iterate
./ciborium

To test on device:
# prereq for happy case
# * udisks2 polkit rules set to "yes" for everything
# * make /media writable
GOARCH=arm go build launchpad.net/ciborium/cmd/ciborium
adb push ciborium /tmp
adb shell
sudo -iu phablet
/tmp/ciborium

[lp:~sergiusens/ciborium/inital_implementation]

3. By Sergio Schvezov on 2014-08-05

Reformatting messages

[Ricardo Salveti (rsalveti)]

Looks fine, go for it.

review: Approve

=== added directory 'cmd'
=== added directory 'cmd/ciborium'
=== added file 'cmd/ciborium/main.go'
--- cmd/ciborium/main.go	1970-01-01 00:00:00 +0000
+++ cmd/ciborium/main.go	2014-08-05 02:16:17 +0000
@@ -0,0 +1,89 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * Authors:
+ * Sergio Schvezov: [e-mail]
+ *
+ * ciborium is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * nuntium 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package main
+
+import (
+	"fmt"
+	"log"
+	"time"
+
+	"launchpad.net/ciborium/notifications"
+	"launchpad.net/ciborium/udisks2"
+	"launchpad.net/go-dbus/v1"
+)
+
+type message struct{ Summary, Body string }
+
+var (
+	msgStorageSucces message = message{
+		Summary: "Storage device detected",
+		Body:    "This device will be scanned for new content",
+	}
+
+	msgStorageFail message = message{
+		Summary: "Failed to add storage device",
+		Body:    "Make sure the storage device is correctly formated",
+	}
+)
+
+var supportedFS []string = []string{"vfat"}
+
+func main() {
+	var (
+		systemBus, sessionBus *dbus.Connection
+		err                   error
+	)
+
+	if systemBus, err = dbus.Connect(dbus.SystemBus); err != nil {
+		log.Fatal("Connection error: ", err)
+	}
+	log.Print("Using system bus on ", systemBus.UniqueName)
+
+	if sessionBus, err = dbus.Connect(dbus.SessionBus); err != nil {
+		log.Fatal("Connection error: ", err)
+	}
+	log.Print("Using session bus on ", sessionBus.UniqueName)
+
+	udisks2, err := udisks2.NewStorageWatcher(systemBus, supportedFS...)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	timeout := time.Second * 4
+	n := notifications.NewNotificationHandler(sessionBus, "ciborium", "system-settings", timeout)
+
+	go func() {
+		for a := range udisks2.DriveAdded {
+			if mountpoint, err := a.Mount(systemBus); err != nil {
+				if err := n.SimpleNotify(msgStorageFail.Summary, msgStorageFail.Body); err != nil {
+					log.Println(err)
+				}
+			} else {
+				fmt.Println("Mounted", mountpoint)
+				if err := n.SimpleNotify(msgStorageSucces.Summary, msgStorageSucces.Body); err != nil {
+					log.Println(err)
+				}
+			}
+		}
+	}()
+
+	done := make(chan bool)
+	<-done
+}

=== added directory 'notifications'
=== added file 'notifications/notifications.go'
--- notifications/notifications.go	1970-01-01 00:00:00 +0000
+++ notifications/notifications.go	2014-08-05 02:16:17 +0000
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * Authors:
+ * Sergio Schvezov: [e-mail]
+ *
+ * ciborium is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * nuntium 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// Notifications lives on a well-knwon bus.Address
+
+package notifications
+
+import (
+	"time"
+
+	"launchpad.net/go-dbus/v1"
+)
+
+const (
+	dbusName         = "org.freedesktop.Notifications"
+	dbusInterface    = "org.freedesktop.Notifications"
+	dbusPath         = "/org/freedesktop/Notifications"
+	dbusNotifyMethod = "Notify"
+)
+
+type VariantMap map[string]dbus.Variant
+
+type Notification struct {
+	dbusObject    *dbus.ObjectProxy
+	appName, icon string
+	timeout       int32
+}
+
+func NewNotificationHandler(conn *dbus.Connection, appName, icon string, timeout time.Duration) *Notification {
+	return &Notification{
+		dbusObject: conn.Object(dbusName, dbusPath),
+		appName:    appName,
+		icon:       icon,
+		timeout:    int32(timeout.Seconds()) * 1000,
+	}
+}
+
+func (n *Notification) SimpleNotify(summary, body string) error {
+	return n.Notify(summary, body, nil, nil)
+}
+
+func (n *Notification) Notify(summary, body string, actions []string, hints VariantMap) error {
+	var reuseId uint32
+	if _, err := n.dbusObject.Call(dbusInterface, dbusNotifyMethod, n.appName, reuseId, n.icon, summary, body, actions, hints, n.timeout); err != nil {
+		return err
+	}
+	return nil
+}

=== added directory 'udisks2'
=== added file 'udisks2/udisks2.go'
--- udisks2/udisks2.go	1970-01-01 00:00:00 +0000
+++ udisks2/udisks2.go	2014-08-05 02:16:17 +0000
@@ -0,0 +1,178 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * Authors:
+ * Sergio Schvezov: [e-mail]
+ *
+ * ciborium is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * nuntium 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package udisks2
+
+import (
+	"reflect"
+	"runtime"
+	"sort"
+
+	"log"
+
+	"launchpad.net/go-dbus/v1"
+)
+
+const (
+	dbusName                   = "org.freedesktop.UDisks2"
+	dbusObject                 = "/org/freedesktop/UDisks2"
+	dbusObjectManagerInterface = "org.freedesktop.DBus.ObjectManager"
+	dbusBlockInterface         = "org.freedesktop.UDisks2.Block"
+	dbusFilesystemInterface    = "org.freedesktop.UDisks2.Filesystem"
+	dbusAddedSignal            = "InterfacesAdded"
+	dbusRemovedSignal          = "InterfacesRemoved"
+)
+
+type VariantMap map[string]dbus.Variant
+type InterfacesAndProperties map[string]VariantMap
+
+type Storage struct {
+	Path  dbus.ObjectPath
+	Props InterfacesAndProperties
+}
+
+type driveMap map[dbus.ObjectPath]InterfacesAndProperties
+
+type UDisks2 struct {
+	conn       *dbus.Connection
+	validFS    sort.StringSlice
+	DriveAdded chan *Storage
+	driveAdded *dbus.SignalWatch
+	drives     driveMap
+}
+
+func (u *UDisks2) connectToSignal(path dbus.ObjectPath, inter, member string) (*dbus.SignalWatch, error) {
+	w, err := u.conn.WatchSignal(&dbus.MatchRule{
+		Type:      dbus.TypeSignal,
+		Sender:    dbusName,
+		Interface: dbusObjectManagerInterface,
+		Member:    member,
+		Path:      path})
+	return w, err
+}
+
+func (u *UDisks2) connectToSignalInterfacesAdded() (*dbus.SignalWatch, error) {
+	return u.connectToSignal(dbusObject, dbusObjectManagerInterface, dbusAddedSignal)
+}
+
+func (u *UDisks2) initInterfacesAddedChan() {
+	go func() {
+		for msg := range u.driveAdded.C {
+			var addedEvent Storage
+			if err := msg.Args(&addedEvent.Path, &addedEvent.Props); err != nil {
+				log.Print(err)
+				continue
+			}
+			if addedEvent.desiredEvent(u.validFS) {
+				u.DriveAdded <- &addedEvent
+			}
+		}
+		log.Print("Shutting down InterfacesAdded channel")
+		close(u.DriveAdded)
+	}()
+
+	u.emitExistingDevices()
+}
+
+func (u *UDisks2) emitExistingDevices() {
+	obj := u.conn.Object(dbusName, dbusObject)
+	reply, err := obj.Call(dbusObjectManagerInterface, "GetManagedObjects")
+	if err != nil {
+		log.Println("Cannot get initial state for devices:", err)
+	}
+
+	allDevices := make(map[dbus.ObjectPath]InterfacesAndProperties)
+	if err := reply.Args(&allDevices); err != nil {
+		log.Println("Cannot get initial state for devices:", err)
+	}
+
+	for objectPath, props := range allDevices {
+		s := Storage{objectPath, props}
+		if s.desiredEvent(u.validFS) {
+			u.DriveAdded <- &s
+		}
+	}
+}
+
+func NewStorageWatcher(conn *dbus.Connection, filesystems ...string) (u *UDisks2, err error) {
+	u = &UDisks2{
+		conn:       conn,
+		validFS:    sort.StringSlice(filesystems),
+		DriveAdded: make(chan *Storage),
+	}
+	if err := u.initDriveWatch(); err != nil {
+		return &UDisks2{}, err
+	}
+	runtime.SetFinalizer(u, cleanDriveWatch)
+	return u, nil
+}
+
+func cleanDriveWatch(u *UDisks2) {
+	log.Print("Cancelling InterfacesAdded signal watch")
+	u.driveAdded.Cancel()
+}
+
+func (u *UDisks2) initDriveWatch() (err error) {
+	if u.driveAdded, err = u.connectToSignalInterfacesAdded(); err != nil {
+		return err
+	}
+	u.initInterfacesAddedChan()
+	return nil
+}
+
+func (s *Storage) desiredEvent(validFS sort.StringSlice) bool {
+	if _, ok := s.Props[dbusFilesystemInterface]; !ok {
+		return false
+	}
+
+	propBlock, ok := s.Props[dbusBlockInterface]
+	if !ok {
+		log.Println("Doesn't hold block interface")
+		return false
+	}
+	id, ok := propBlock["IdType"]
+	if !ok {
+		log.Println("Doesn't hold IdType")
+		return false
+	}
+
+	fs := reflect.ValueOf(id.Value).String()
+	i := validFS.Search(fs)
+	if i >= validFS.Len() || validFS[i] != fs {
+		log.Println(fs, "not in:", validFS)
+		return false
+	}
+
+	return true
+}
+
+func (s *Storage) Mount(conn *dbus.Connection) (mountpoint string, err error) {
+	obj := conn.Object(dbusName, s.Path)
+	options := make(VariantMap)
+	options["auth.no_user_interaction"] = dbus.Variant{true}
+	reply, err := obj.Call(dbusFilesystemInterface, "Mount", options)
+	if err != nil {
+		return "", err
+	}
+	if err := reply.Args(&mountpoint); err != nil {
+		return "", err
+	}
+
+	return mountpoint, err
+}