Don't Panic: Forward all errors as error values. Read this for reference: https://dave.cheney.net/2012/01/18/why-go-gets-exceptions-right

Author: phommel

Diff for: AccessPoint.go

@@ -24,36 +24,36 @@ type AccessPoint interface {
 	GetPath() dbus.ObjectPath
 
 	// GetFlags gets flags describing the capabilities of the access point.
-	GetFlags() uint32
+	GetFlags() (uint32, error)
 
 	// GetWPAFlags gets flags describing the access point's capabilities
 	// according to WPA (Wifi Protected Access).
-	GetWPAFlags() uint32
+	GetWPAFlags() (uint32, error)
 
 	// GetRSNFlags gets flags describing the access point's capabilities
 	// according to the RSN (Robust Secure Network) protocol.
-	GetRSNFlags() uint32
+	GetRSNFlags() (uint32, error)
 
 	// GetSSID returns the Service Set Identifier identifying the access point.
-	GetSSID() string
+	GetSSID() (string, error)
 
 	// GetFrequency gets the radio channel frequency in use by the access point,
 	// in MHz.
-	GetFrequency() uint32
+	GetFrequency() (uint32, error)
 
 	// GetHWAddress gets the hardware address (BSSID) of the access point.
-	GetHWAddress() string
+	GetHWAddress() (string, error)
 
 	// GetMode describes the operating mode of the access point.
-	GetMode() Nm80211Mode
+	GetMode() (Nm80211Mode, error)
 
 	// GetMaxBitrate gets the maximum bitrate this access point is capable of, in
 	// kilobits/second (Kb/s).
-	GetMaxBitrate() uint32
+	GetMaxBitrate() (uint32, error)
 
 	// GetStrength gets the current signal quality of the access point, in
 	// percent.
-	GetStrength() uint8
+	GetStrength() (uint8, error)
 
 	MarshalJSON() ([]byte, error)
 }
@@ -71,52 +71,97 @@ func (a *accessPoint) GetPath() dbus.ObjectPath {
 	return a.obj.Path()
 }
 
-func (a *accessPoint) GetFlags() uint32 {
+func (a *accessPoint) GetFlags() (uint32, error) {
 	return a.getUint32Property(AccessPointPropertyFlags)
 }
 
-func (a *accessPoint) GetWPAFlags() uint32 {
+func (a *accessPoint) GetWPAFlags() (uint32, error) {
 	return a.getUint32Property(AccessPointPropertyWPAFlags)
 }
 
-func (a *accessPoint) GetRSNFlags() uint32 {
+func (a *accessPoint) GetRSNFlags() (uint32, error) {
 	return a.getUint32Property(AccessPointPropertyRSNFlags)
 }
 
-func (a *accessPoint) GetSSID() string {
-	return string(a.getSliceByteProperty(AccessPointPropertySSID))
+func (a *accessPoint) GetSSID() (string, error) {
+	r, err := a.getSliceByteProperty(AccessPointPropertySSID)
+	if err != nil {
+		return "", err
+	}
+	return string(r), nil
 }
 
-func (a *accessPoint) GetFrequency() uint32 {
+func (a *accessPoint) GetFrequency() (uint32, error) {
 	return a.getUint32Property(AccessPointPropertyFrequency)
 }
 
-func (a *accessPoint) GetHWAddress() string {
+func (a *accessPoint) GetHWAddress() (string, error) {
 	return a.getStringProperty(AccessPointPropertyHWAddress)
 }
 
-func (a *accessPoint) GetMode() Nm80211Mode {
-	return Nm80211Mode(a.getUint32Property(AccessPointPropertyMode))
+func (a *accessPoint) GetMode() (Nm80211Mode, error) {
+	r, err := a.getUint32Property(AccessPointPropertyMode)
+	if err != nil {
+		return Nm80211ModeUnknown, err
+	}
+	return Nm80211Mode(r), nil
 }
 
-func (a *accessPoint) GetMaxBitrate() uint32 {
+func (a *accessPoint) GetMaxBitrate() (uint32, error) {
 	return a.getUint32Property(AccessPointPropertyMaxBitrate)
 }
 
-func (a *accessPoint) GetStrength() uint8 {
+func (a *accessPoint) GetStrength() (uint8, error) {
 	return a.getUint8Property(AccessPointPropertyStrength)
 }
 
 func (a *accessPoint) MarshalJSON() ([]byte, error) {
+	Flags, err := a.GetFlags()
+	if err != nil {
+		return nil, err
+	}
+	WPAFlags, err := a.GetWPAFlags()
+	if err != nil {
+		return nil, err
+	}
+	RSNFlags, err := a.GetRSNFlags()
+	if err != nil {
+		return nil, err
+	}
+	SSID, err := a.GetSSID()
+	if err != nil {
+		return nil, err
+	}
+	Frequency, err := a.GetFrequency()
+	if err != nil {
+		return nil, err
+	}
+	HWAddress, err := a.GetHWAddress()
+	if err != nil {
+		return nil, err
+	}
+	Mode, err := a.GetMode()
+	if err != nil {
+		return nil, err
+	}
+	MaxBitrate, err := a.GetMaxBitrate()
+	if err != nil {
+		return nil, err
+	}
+	Strength, err := a.GetStrength()
+	if err != nil {
+		return nil, err
+	}
+
 	return json.Marshal(map[string]interface{}{
-		"Flags":      a.GetFlags(),
-		"WPAFlags":   a.GetWPAFlags(),
-		"RSNFlags":   a.GetRSNFlags(),
-		"SSID":       a.GetSSID(),
-		"Frequency":  a.GetFrequency(),
-		"HWAddress":  a.GetHWAddress(),
-		"Mode":       a.GetMode().String(),
-		"MaxBitrate": a.GetMaxBitrate(),
-		"Strength":   a.GetStrength(),
+		"Flags":      Flags,
+		"WPAFlags":   WPAFlags,
+		"RSNFlags":   RSNFlags,
+		"SSID":       SSID,
+		"Frequency":  Frequency,
+		"HWAddress":  HWAddress,
+		"Mode":       Mode.String(),
+		"MaxBitrate": MaxBitrate,
+		"Strength":   Strength,
 	})
 }

Diff for: ActiveConnection.go

@@ -24,43 +24,43 @@ const (
 
 type ActiveConnection interface {
 	// GetConnection gets connection object of the connection.
-	GetConnection() Connection
+	GetConnection() (Connection, error)
 
 	// GetSpecificObject gets a specific object associated with the active connection.
-	GetSpecificObject() AccessPoint
+	GetSpecificObject() (AccessPoint, error)
 
 	// GetID gets the ID of the connection.
-	GetID() string
+	GetID() (string, error)
 
 	// GetUUID gets the UUID of the connection.
-	GetUUID() string
+	GetUUID() (string, error)
 
 	// GetType gets the type of the connection.
-	GetType() string
+	GetType() (string, error)
 
 	// GetDevices gets array of device objects which are part of this active connection.
-	GetDevices() []Device
+	GetDevices() ([]Device, error)
 
 	// GetState gets the state of the connection.
-	GetState() uint32
+	GetState() (uint32, error)
 
 	// GetStateFlags gets the state flags of the connection.
-	GetStateFlags() uint32
+	GetStateFlags() (uint32, error)
 
 	// GetDefault gets the default IPv4 flag of the connection.
-	GetDefault() bool
+	GetDefault() (bool, error)
 
 	// GetIP4Config gets the IP4Config of the connection.
-	GetIP4Config() IP4Config
+	GetIP4Config() (IP4Config, error)
 
 	// GetDHCP4Config gets the DHCP4Config of the connection.
-	GetDHCP4Config() DHCP4Config
+	GetDHCP4Config() (DHCP4Config, error)
 
 	// GetVPN gets the VPN flag of the connection.
-	GetVPN() bool
+	GetVPN() (bool, error)
 
 	// GetMaster gets the master device of the connection.
-	GetMaster() Device
+	GetMaster() (Device, error)
 }
 
 func NewActiveConnection(objectPath dbus.ObjectPath) (ActiveConnection, error) {
@@ -72,90 +72,113 @@ type activeConnection struct {
 	dbusBase
 }
 
-func (a *activeConnection) GetConnection() Connection {
-	path := a.getObjectProperty(ActiveConnectionProperyConnection)
+func (a *activeConnection) GetConnection() (Connection, error) {
+	path, err := a.getObjectProperty(ActiveConnectionProperyConnection)
+	if err != nil {
+		return nil, err
+	}
 	con, err := NewConnection(path)
 	if err != nil {
-		panic(err)
+		return nil, err
 	}
-	return con
+	return con, nil
 }
 
-func (a *activeConnection) GetSpecificObject() AccessPoint {
-	path := a.getObjectProperty(ActiveConnectionProperySpecificObject)
+func (a *activeConnection) GetSpecificObject() (AccessPoint, error) {
+	path, err := a.getObjectProperty(ActiveConnectionProperySpecificObject)
+	if err != nil {
+		return nil, err
+	}
 	ap, err := NewAccessPoint(path)
 	if err != nil {
-		panic(err)
+		return nil, err
 	}
-	return ap
+	return ap, nil
 }
 
-func (a *activeConnection) GetID() string {
+func (a *activeConnection) GetID() (string, error) {
 	return a.getStringProperty(ActiveConnectionProperyID)
 }
 
-func (a *activeConnection) GetUUID() string {
+func (a *activeConnection) GetUUID() (string, error) {
 	return a.getStringProperty(ActiveConnectionProperyUUID)
 }
 
-func (a *activeConnection) GetType() string {
+func (a *activeConnection) GetType() (string, error) {
 	return a.getStringProperty(ActiveConnectionProperyType)
 }
 
-func (a *activeConnection) GetDevices() []Device {
-	paths := a.getSliceObjectProperty(ActiveConnectionProperyDevices)
+func (a *activeConnection) GetDevices() ([]Device, error) {
+	paths, err := a.getSliceObjectProperty(ActiveConnectionProperyDevices)
+	if err != nil {
+		return nil, err
+	}
 	devices := make([]Device, len(paths))
-	var err error
 	for i, path := range paths {
 		devices[i], err = DeviceFactory(path)
 		if err != nil {
-			panic(err)
+			return nil, err
 		}
 	}
-	return devices
+	return devices, nil
 }
 
-func (a *activeConnection) GetState() uint32 {
+func (a *activeConnection) GetState() (uint32, error) {
 	return a.getUint32Property(ActiveConnectionProperyState)
 }
 
-func (a *activeConnection) GetStateFlags() uint32 {
+func (a *activeConnection) GetStateFlags() (uint32, error) {
 	return a.getUint32Property(ActiveConnectionProperyStateFlags)
 }
 
-func (a *activeConnection) GetDefault() bool {
-	b := a.getProperty(ActiveConnectionProperyDefault)
-	return b.(bool)
+func (a *activeConnection) GetDefault() (bool, error) {
+	b, err := a.getProperty(ActiveConnectionProperyDefault)
+	if err != nil {
+		return false, err
+	}
+	return b.(bool), nil
 }
 
-func (a *activeConnection) GetIP4Config() IP4Config {
-	path := a.getObjectProperty(ActiveConnectionProperyIP4Config)
+func (a *activeConnection) GetIP4Config() (IP4Config, error) {
+	path, err := a.getObjectProperty(ActiveConnectionProperyIP4Config)
+	if err != nil {
+		return nil, err
+	}
 	r, err := NewIP4Config(path)
 	if err != nil {
-		panic(err)
+		return nil, err
 	}
-	return r
+	return r, nil
 }
 
-func (a *activeConnection) GetDHCP4Config() DHCP4Config {
-	path := a.getObjectProperty(ActiveConnectionProperyDHCP4Config)
+func (a *activeConnection) GetDHCP4Config() (DHCP4Config, error) {
+	path, err := a.getObjectProperty(ActiveConnectionProperyDHCP4Config)
+	if err != nil {
+		return nil, err
+	}
 	r, err := NewDHCP4Config(path)
 	if err != nil {
-		panic(err)
+		return nil, err
 	}
-	return r
+	return r, nil
 }
 
-func (a *activeConnection) GetVPN() bool {
-	ret := a.getProperty(ActiveConnectionProperyVPN)
-	return ret.(bool)
+func (a *activeConnection) GetVPN() (bool, error) {
+	ret, err := a.getProperty(ActiveConnectionProperyVPN)
+	if err != nil {
+		return false, err
+	}
+	return ret.(bool), nil
 }
 
-func (a *activeConnection) GetMaster() Device {
-	path := a.getObjectProperty(ActiveConnectionProperyMaster)
+func (a *activeConnection) GetMaster() (Device, error) {
+	path, err := a.getObjectProperty(ActiveConnectionProperyMaster)
+	if err != nil {
+		return nil, err
+	}
 	r, err := DeviceFactory(path)
 	if err != nil {
-		panic(err)
+		return nil, err
 	}
-	return r
+	return r, nil
 }