Merge commit '25a157e6614739fbd4df1da3d11d46afe72ae9a8' as 'v2'

v2/internal/app/default.go

@@ -0,0 +1,41 @@
+// +build !desktop,!hybrid,!server
+
+package app
+
+// This is the default application that will get run if the user compiles using `go build`.
+// The reason we want to prevent that is that the `wails build` command does a lot of behind
+// the scenes work such as asset compilation. If we allow `go build`, the state of these assets
+// will be unknown and the application will not work as expected.
+
+import (
+	"os"
+
+	"github.com/leaanthony/wailsv2/v2/internal/features"
+)
+
+// App defines a Wails application structure
+type App struct {
+	Title     string
+	Width     int
+	Height    int
+	Resizable bool
+
+	Features *features.Features
+}
+
+// CreateApp returns a null application
+func CreateApp(options *Options) *App {
+	return &App{}
+}
+
+// Run the application
+func (a *App) Run() error {
+	println(`FATAL: This application was built using "go build". This is unsupported. Please compile using "wails build".`)
+	os.Exit(1)
+	return nil
+}
+
+// Bind the dummy interface
+func (a *App) Bind(dummy interface{}) error {
+	return nil
+}

v2/internal/app/desktop.go

@@ -0,0 +1,164 @@
+// +build desktop,!server
+
+package app
+
+import (
+	"os"
+
+	"github.com/leaanthony/wailsv2/v2/internal/binding"
+	"github.com/leaanthony/wailsv2/v2/internal/features"
+	"github.com/leaanthony/wailsv2/v2/internal/ffenestri"
+	"github.com/leaanthony/wailsv2/v2/internal/logger"
+	"github.com/leaanthony/wailsv2/v2/internal/messagedispatcher"
+	"github.com/leaanthony/wailsv2/v2/internal/servicebus"
+	"github.com/leaanthony/wailsv2/v2/internal/signal"
+	"github.com/leaanthony/wailsv2/v2/internal/subsystem"
+)
+
+// App defines a Wails application structure
+type App struct {
+	window     *ffenestri.Application
+	servicebus *servicebus.ServiceBus
+	logger     *logger.Logger
+	signal     *signal.Manager
+
+	// Subsystems
+	log        *subsystem.Log
+	runtime    *subsystem.Runtime
+	event      *subsystem.Event
+	binding    *subsystem.Binding
+	call       *subsystem.Call
+	dispatcher *messagedispatcher.Dispatcher
+
+	// This is our binding DB
+	bindings *binding.Bindings
+
+	// Feature flags
+	Features *features.Features
+}
+
+// Create App
+func CreateApp(options *Options) *App {
+
+	// Merge default options
+	options.mergeDefaults()
+
+	// Set up logger
+	myLogger := logger.New(os.Stdout)
+	myLogger.SetLogLevel(logger.TRACE)
+
+	window := ffenestri.NewApplicationWithConfig(&ffenestri.Config{
+		Title:     options.Title,
+		Width:     options.Width,
+		Height:    options.Height,
+		MinWidth:  options.MinWidth,
+		MinHeight: options.MinHeight,
+		MaxWidth:  options.MaxWidth,
+		MaxHeight: options.MaxHeight,
+		Frameless: options.Frameless,
+
+		// This should be controlled by the compile time flags...
+		DevTools: true,
+
+		Resizable:  !options.DisableResize,
+		Fullscreen: options.Fullscreen,
+	}, myLogger)
+
+	result := &App{
+		window:     window,
+		servicebus: servicebus.New(myLogger),
+		logger:     myLogger,
+		bindings:   binding.NewBindings(myLogger),
+		Features:   features.New(),
+	}
+
+	return result
+
+}
+
+// Run the application
+func (a *App) Run() error {
+
+	// Setup signal handler
+	signal, err := signal.NewManager(a.servicebus, a.logger)
+	if err != nil {
+		return err
+	}
+	a.signal = signal
+	a.signal.Start()
+
+	// Start the service bus
+	a.servicebus.Debug()
+	a.servicebus.Start()
+
+	// Start the runtime
+	runtime, err := subsystem.NewRuntime(a.servicebus, a.logger)
+	if err != nil {
+		return err
+	}
+	a.runtime = runtime
+	a.runtime.Start()
+
+	// Start the binding subsystem
+	binding, err := subsystem.NewBinding(a.servicebus, a.logger, a.bindings, a.runtime.GoRuntime())
+	if err != nil {
+		return err
+	}
+	a.binding = binding
+	a.binding.Start()
+
+	// Start the logging subsystem
+	log, err := subsystem.NewLog(a.servicebus, a.logger)
+	if err != nil {
+		return err
+	}
+	a.log = log
+	a.log.Start()
+
+	// create the dispatcher
+	dispatcher, err := messagedispatcher.New(a.servicebus, a.logger)
+	if err != nil {
+		return err
+	}
+	a.dispatcher = dispatcher
+	dispatcher.Start()
+
+	// Start the eventing subsystem
+	event, err := subsystem.NewEvent(a.servicebus, a.logger)
+	if err != nil {
+		return err
+	}
+	a.event = event
+	a.event.Start()
+
+	// Start the call subsystem
+	call, err := subsystem.NewCall(a.servicebus, a.logger, a.bindings.DB())
+	if err != nil {
+		return err
+	}
+	a.call = call
+	a.call.Start()
+
+	// Dump bindings as a debug
+	bindingDump, err := a.bindings.ToJSON()
+	if err != nil {
+		return err
+	}
+
+	result := a.window.Run(dispatcher, bindingDump, a.Features)
+	a.logger.Trace("Ffenestri.Run() exited")
+	a.servicebus.Stop()
+
+	return result
+}
+
+// Bind a struct to the application by passing in
+// a pointer to it
+func (a *App) Bind(structPtr interface{}) {
+
+	// Add the struct to the bindings
+	err := a.bindings.Add(structPtr)
+	if err != nil {
+		a.logger.Fatal("Error during binding: " + err.Error())
+	}
+}

v2/internal/app/hybrid.go

@@ -0,0 +1,206 @@
+// +build !server,!desktop,hybrid
+
+package app
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/leaanthony/clir"
+	"github.com/leaanthony/wailsv2/v2/internal/binding"
+	"github.com/leaanthony/wailsv2/v2/internal/features"
+	"github.com/leaanthony/wailsv2/v2/internal/ffenestri"
+	"github.com/leaanthony/wailsv2/v2/internal/logger"
+	"github.com/leaanthony/wailsv2/v2/internal/messagedispatcher"
+	"github.com/leaanthony/wailsv2/v2/internal/servicebus"
+	"github.com/leaanthony/wailsv2/v2/internal/subsystem"
+	"github.com/leaanthony/wailsv2/v2/internal/webserver"
+)
+
+// Config defines the Application's configuration
+type Config struct {
+	Title         string // Title is the value to be displayed in the title bar
+	Width         int    // Width is the desired window width
+	Height        int    // Height is the desired window height
+	DevTools      bool   // DevTools enables or disables the browser development tools
+	Resizable     bool   // Resizable when False prevents window resizing
+	ServerEnabled bool   // ServerEnabled when True allows remote connections
+}
+
+// App defines a Wails application structure
+type App struct {
+	config    Config
+	window    *ffenestri.Application
+	webserver *webserver.WebServer
+	binding   *subsystem.Binding
+	call      *subsystem.Call
+	event     *subsystem.Event
+	log       *subsystem.Log
+	runtime   *subsystem.Runtime
+
+	bindings   *binding.Bindings
+	logger     *logger.Logger
+	dispatcher *messagedispatcher.Dispatcher
+	servicebus *servicebus.ServiceBus
+
+	// Feature flags
+	Features *features.Features
+}
+
+// Create App
+func CreateApp(options *Options) *App {
+
+	// Merge default options
+	options.mergeDefaults()
+
+	// Set up logger
+	myLogger := logger.New(os.Stdout)
+	myLogger.SetLogLevel(logger.INFO)
+
+	window := ffenestri.NewApplicationWithConfig(&ffenestri.Config{
+		Title:     options.Title,
+		Width:     options.Width,
+		Height:    options.Height,
+		MinWidth:  options.MinWidth,
+		MinHeight: options.MinHeight,
+		MaxWidth:  options.MaxWidth,
+		MaxHeight: options.MaxHeight,
+		Frameless: options.Frameless,
+
+		// This should be controlled by the compile time flags...
+		DevTools: true,
+
+		Resizable:  !options.DisableResize,
+		Fullscreen: options.Fullscreen,
+	}, myLogger)
+
+	app := &App{
+		window:     window,
+		webserver:  webserver.NewWebServer(myLogger),
+		servicebus: servicebus.New(myLogger),
+		logger:     myLogger,
+		bindings:   binding.NewBindings(myLogger),
+	}
+
+	return app
+}
+
+// Run the application
+func (a *App) Run() error {
+
+	// Default app options
+	var port = 8080
+	var ip = "localhost"
+	var suppressLogging = false
+
+	// Create CLI
+	cli := clir.NewCli(filepath.Base(os.Args[0]), "Desktop/Server Build", "")
+
+	// Setup flags
+	cli.IntFlag("p", "Port to serve on", &port)
+	cli.StringFlag("i", "IP to serve on", &ip)
+	cli.BoolFlag("q", "Suppress logging", &suppressLogging)
+
+	// Setup main action
+	cli.Action(func() error {
+
+		// Set IP + Port
+		a.webserver.SetPort(port)
+		a.webserver.SetIP(ip)
+		a.webserver.SetBindings(a.bindings)
+		// Log information (if we aren't suppressing it)
+		if !suppressLogging {
+			cli.PrintBanner()
+			a.logger.Info("Running server at %s", a.webserver.URL())
+		}
+
+		a.servicebus.Start()
+		log, err := subsystem.NewLog(a.servicebus, a.logger)
+		if err != nil {
+			return err
+		}
+		a.log = log
+		a.log.Start()
+		dispatcher, err := messagedispatcher.New(a.servicebus, a.logger)
+		if err != nil {
+			return err
+		}
+		a.dispatcher = dispatcher
+		a.dispatcher.Start()
+
+		// Start the runtime
+		runtime, err := subsystem.NewRuntime(a.servicebus, a.logger)
+		if err != nil {
+			return err
+		}
+		a.runtime = runtime
+		a.runtime.Start()
+
+		// Start the binding subsystem
+		binding, err := subsystem.NewBinding(a.servicebus, a.logger, a.bindings, runtime.GoRuntime())
+		if err != nil {
+			return err
+		}
+		a.binding = binding
+		a.binding.Start()
+
+		// Start the eventing subsystem
+		event, err := subsystem.NewEvent(a.servicebus, a.logger)
+		if err != nil {
+			return err
+		}
+		a.event = event
+		a.event.Start()
+
+		// Start the call subsystem
+		call, err := subsystem.NewCall(a.servicebus, a.logger, a.bindings.DB())
+		if err != nil {
+			return err
+		}
+		a.call = call
+		a.call.Start()
+
+		// Required so that the WailsInit functions are fired!
+		runtime.GoRuntime().Events.Emit("wails:loaded")
+
+		// Set IP + Port
+		a.webserver.SetPort(port)
+		a.webserver.SetIP(ip)
+
+		// Log information (if we aren't suppressing it)
+		if !suppressLogging {
+			cli.PrintBanner()
+			println("Running server at " + a.webserver.URL())
+		}
+
+		// Dump bindings as a debug
+		bindingDump, err := a.bindings.ToJSON()
+		if err != nil {
+			return err
+		}
+
+		go func() {
+			if err := a.webserver.Start(dispatcher, event); err != nil {
+				a.logger.Error("Webserver failed to start %s", err)
+			}
+		}()
+
+		result := a.window.Run(dispatcher, bindingDump, a.Features)
+		a.servicebus.Stop()
+
+		return result
+	})
+
+	return cli.Run()
+}
+
+// Bind a struct to the application by passing in
+// a pointer to it
+func (a *App) Bind(structPtr interface{}) {
+
+	// Add the struct to the bindings
+	err := a.bindings.Add(structPtr)
+	if err != nil {
+		a.logger.Fatal("Error during binding: " + err.Error())
+	}
+}

v2/internal/app/options.go

@@ -0,0 +1,34 @@
+package app
+
+// Options for creating the App
+type Options struct {
+	Title         string
+	Width         int
+	Height        int
+	DisableResize bool
+	Fullscreen    bool
+	Frameless     bool
+	MinWidth      int
+	MinHeight     int
+	MaxWidth      int
+	MaxHeight     int
+}
+
+// mergeDefaults will set the minimum default values for an application
+func (o *Options) mergeDefaults() {
+
+	// Create a default title
+	if len(o.Title) == 0 {
+		o.Title = "My Wails App"
+	}
+
+	// Default width
+	if o.Width == 0 {
+		o.Width = 1024
+	}
+
+	// Default height
+	if o.Height == 0 {
+		o.Height = 768
+	}
+}

v2/internal/app/server.go

@@ -0,0 +1,155 @@
+// +build server,!desktop
+
+package app
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/leaanthony/clir"
+	"github.com/leaanthony/wailsv2/v2/internal/binding"
+	"github.com/leaanthony/wailsv2/v2/internal/logger"
+	"github.com/leaanthony/wailsv2/v2/internal/messagedispatcher"
+	"github.com/leaanthony/wailsv2/v2/internal/servicebus"
+	"github.com/leaanthony/wailsv2/v2/internal/subsystem"
+	"github.com/leaanthony/wailsv2/v2/internal/webserver"
+)
+
+// App defines a Wails application structure
+type App struct {
+	binding *subsystem.Binding
+	call    *subsystem.Call
+	event   *subsystem.Event
+	log     *subsystem.Log
+	runtime *subsystem.Runtime
+
+	bindings   *binding.Bindings
+	logger     *logger.Logger
+	dispatcher *messagedispatcher.Dispatcher
+	servicebus *servicebus.ServiceBus
+	webserver  *webserver.WebServer
+}
+
+// Create App
+func CreateApp(options *Options) *App {
+	options.mergeDefaults()
+	// We ignore the inputs (for now)
+
+	// TODO: Allow logger output override on CLI
+	myLogger := logger.New(os.Stdout)
+	myLogger.SetLogLevel(logger.TRACE)
+
+	result := &App{
+		bindings:   binding.NewBindings(myLogger),
+		logger:     myLogger,
+		servicebus: servicebus.New(myLogger),
+		webserver:  webserver.NewWebServer(myLogger),
+	}
+
+	return result
+}
+
+// Run the application
+func (a *App) Run() error {
+
+	// Default app options
+	var port = 8080
+	var ip = "localhost"
+	var supressLogging = false
+	var debugMode = false
+
+	// Create CLI
+	cli := clir.NewCli(filepath.Base(os.Args[0]), "Server Build", "")
+
+	// Setup flags
+	cli.IntFlag("p", "Port to serve on", &port)
+	cli.StringFlag("i", "IP to serve on", &ip)
+	cli.BoolFlag("d", "Debug mode", &debugMode)
+	cli.BoolFlag("q", "Supress logging", &supressLogging)
+
+	// Setup main action
+	cli.Action(func() error {
+
+		// Set IP + Port
+		a.webserver.SetPort(port)
+		a.webserver.SetIP(ip)
+		a.webserver.SetBindings(a.bindings)
+		// Log information (if we aren't supressing it)
+		if !supressLogging {
+			cli.PrintBanner()
+			a.logger.Info("Running server at %s", a.webserver.URL())
+		}
+
+		if debugMode {
+			a.servicebus.Debug()
+		}
+		a.servicebus.Start()
+		log, err := subsystem.NewLog(a.servicebus, a.logger)
+		if err != nil {
+			return err
+		}
+		a.log = log
+		a.log.Start()
+		dispatcher, err := messagedispatcher.New(a.servicebus, a.logger)
+		if err != nil {
+			return err
+		}
+		a.dispatcher = dispatcher
+		a.dispatcher.Start()
+
+		// Start the runtime
+		runtime, err := subsystem.NewRuntime(a.servicebus, a.logger)
+		if err != nil {
+			return err
+		}
+		a.runtime = runtime
+		a.runtime.Start()
+
+		// Start the binding subsystem
+		binding, err := subsystem.NewBinding(a.servicebus, a.logger, a.bindings, runtime.GoRuntime())
+		if err != nil {
+			return err
+		}
+		a.binding = binding
+		a.binding.Start()
+
+		// Start the eventing subsystem
+		event, err := subsystem.NewEvent(a.servicebus, a.logger)
+		if err != nil {
+			return err
+		}
+		a.event = event
+		a.event.Start()
+
+		// Start the call subsystem
+		call, err := subsystem.NewCall(a.servicebus, a.logger, a.bindings.DB())
+		if err != nil {
+			return err
+		}
+		a.call = call
+		a.call.Start()
+
+		// Required so that the WailsInit functions are fired!
+		runtime.GoRuntime().Events.Emit("wails:loaded")
+
+		if err := a.webserver.Start(dispatcher, event); err != nil {
+			a.logger.Error("Webserver failed to start %s", err)
+			return err
+		}
+
+		return nil
+	})
+
+	return cli.Run()
+}
+
+// Bind a struct to the application by passing in
+// a pointer to it
+func (a *App) Bind(structPtr interface{}) {
+
+	// Add the struct to the bindings
+	err := a.bindings.Add(structPtr)
+	if err != nil {
+		a.logger.Fatal("Error during binding: " + err.Error())
+	}
+}