merle

type BridgeThingers map[string]func() Thinger

type Bridger interface {

	// Map of Thingers supported by Bridge.  Map keyed by a regular
	// expression (re) of the form: id:model:name specifying which Things
	// can attach to the bridge. E.g.:
	//
	//	return merle.BridgeThingers{
	//		".*:relays:.*": func() merle.Thinger { return relays.NewRelays() },
	//		".*:bmp180:.*": func() merle.Thinger { return bmp180.NewBmp180() },
	//	}
	//
	// In this example, a Thing with [id:model:name] = "01234:relays:foo"
	// would match the first entry.  Another Thing with "8888:foo:bar"
	// would not match either entry and would not attach.
	BridgeThingers() BridgeThingers

	// List of subscribers on Bridge bus.  All packets from all connected
	// Things (children) are forwarded to the Bridge bus and tested against
	// the BridgeSubscribers.
	BridgeSubscribers() Subscribers
}

type Msg struct {
	Msg string
}

type MsgEventStatus struct {
	Msg    string
	Id     string
	Online bool
}

type MsgIdentity struct {
	Msg         string
	Id          string
	Model       string
	Name        string
	Online      bool
	StartupTime time.Time
}

type Packet struct {
	// contains filtered or unexported fields
}

type Subscribers map[string]func(*Packet)

type Thing struct {
	// Thing's configuration
	Cfg ThingConfig
	// contains filtered or unexported fields
}

type ThingAssets struct {

	// Directory on file system for Thing's assets (html, css, js, etc)
	// This is an absolute or relative directory.  If relative, it's
	// relative to the Thing's binary path.
	AssetsDir string

	// Path to Thing's HTML template file, relative to AssetsDir.
	HtmlTemplate string

	// HtmlTemplateText is text passed in lieu of a template file.
	// HtmlTemplateText takes priority over HtmlTemplate, if both are
	// present.
	HtmlTemplateText string
}

type ThingConfig struct {

	// ########## Thing configuration.
	//
	// [Optional] Thing's Id.  Ids are unique within an application to
	// differentiate one Thing from another.  Id is optional; if Id is not
	// given, a system-wide unique Id is assigned.
	Id string

	// Thing's Model.  The default is "Thing".
	Model string

	// Thing's Name.  The default is "Thingy".
	Name string

	// [Optional] system User.  If a User is given, any browser views of
	// the Thing's UI will prompt for user/passwd.  HTTP Basic
	// Authentication is used and the user/passwd given must match the
	// system creditials for the user.  If no user is given, HTTP Basic
	// Authentication is skipped; anyone can view the UI.  The default is
	// "" (skipped).
	User string

	// [Optional] If PortPublic is non-zero, an HTTP web server is started
	// on port PortPublic.  PortPublic is typically set to 80.  The HTTP
	// web server runs Thing's UI.  The default is 0 (no web server).
	PortPublic uint

	// [Optional] If PortPublicTLS is non-zero, an HTTPS web server is
	// started on port PortPublicTLS.  PortPublicTLS is typically set to
	// 443.  The HTTPS web server will self-certify using a certificate
	// from Let's Encrypt.  The public HTTPS server will securely run the
	// Thing's UI.  If PortPublicTLS is given, PortPublic must be given.
	// The default is 0 (no web server).
	PortPublicTLS uint

	// [Optional] If PortPrivate is non-zero, a private HTTP server is
	// started on port PortPrivate.  This HTTP server does not server up
	// the Thing's UI but rather connects to Thing's Mother using a
	// websocket over HTTP.  The default is 0 (no web server).
	PortPrivate uint

	// [Optional] Run as Thing-prime.  The default is false.
	IsPrime bool

	// MaxConnection is maximum number of inbound connections to a Thing.
	// Inbound connections are WebSockets from web browsers or WebSockets
	// from Thing Prime.  The default is 30.  With the default, the 31st
	// (and higher) concurrent WebSocket connection attempt will block,
	// waiting for one of the first 30 WebSocket sessions to terminate.
	MaxConnections uint

	// Logging enable
	LoggingEnabled bool

	// ########## Mother configuration.
	//
	// This section describes a Thing's mother.  Every Thing has a mother.  A
	// mother is also a Thing.  We can build a hierarchy of Things, with a Thing
	// having a mother, a grandmother, a great grandmother, etc.
	//
	// Mother's Host address.  This the IP address or Domain Name of the
	// host running mother.  Host address can be on the local network or across
	// the internet.
	MotherHost string

	// User on host with SSH access into host.  Host should be configured
	// with user's public key so SSH access is password-less.
	MotherUser string

	// Port on Host for Mother's private HTTP server
	MotherPortPrivate uint

	// ########## Bridge configuration.
	//
	// A Thing implementing the Bridger interface will use this config for
	// bridge-specific configuration.
	//
	// Beginning bridge port number.  The bridge will listen for Thing
	// (child) connections on the port range [BeginPort-EndPort].
	//
	// The bridge port range must be within the system's
	// ip_local_reserved_ports.
	//
	// Set a range using:
	//
	//   sudo sysctl -w net.ipv4.ip_local_reserved_ports="6000-6100"
	//
	// Or, to persist setting on next boot, add to /etc/sysctl.conf:
	//
	//   net.ipv4.ip_local_reserved_ports = 6000-6100
	//
	// And then run sudo sysctl -p
	//
	BridgePortBegin uint

	// Ending bridge port number
	BridgePortEnd uint
}

type Thinger interface {

	// Map of Thing's subscribers, keyed by message.  On Packet receipt, a
	// subscriber is looked up by Packet message.  If there is a match, the
	// subscriber callback is called.  If no subscribers match the received
	// message, the "default" subscriber matches.  If still no matches, the
	// Packet is not handled.  If the callback is nil, the Packet is
	// (silently) dropped.  Here is an example of a subscriber map:
	//
	//	func (t *thing) Subscribers() merle.Subscribers {
	//		return merle.Subscribers{
	//			merle.CmdRun:     t.run,
	//			merle.GetState:   t.getState,
	//			merle.ReplyState: t.saveState,
	//			"SpamUpdate":     t.update,
	//			"SpamTimer":      nil,         // silent drop
	//		}
	//	}
	//
	Subscribers() Subscribers

	// Thing's web server assets.
	Assets() *ThingAssets
}