main.go

package main

import (
	"flag"
	"fmt"
	"log/slog"
	"os/exec"

	"github.com/hashicorp/go-plugin"
	"github.com/tinyauthapp/tinyauth-exp/mock"
	"github.com/tinyauthapp/tinyauth-exp/model"
)

var exampleApps = map[string]model.App{
	"foo": {
		Config: model.AppConfig{
			Domain: "foo.example.com",
		},
	},
	"bar": {
		Config: model.AppConfig{
			Domain: "bar.example.com",
		},
	},
}

var pluginMap = map[string]plugin.Plugin{
	"plugin": &model.ACLProvider_Plugin{},
}

var handshakeConfig = plugin.HandshakeConfig{
	ProtocolVersion:  1,
	MagicCookieKey:   model.PluginMagicCookieValue,
	MagicCookieValue: string(model.PluginType_ACL),
}

func main() {
	pluginPath := flag.String("plugin", "", "path to plugin")
	flag.Parse()

	var providers []model.ACLProvider

	slog.Info("registering mock provider")

	providers = append(providers, mock.NewMockACLProvider(exampleApps, "mock", model.ACLType_Static))

	if *pluginPath != "" {
		slog.Info("registering acl provider module")

		c := plugin.NewClient(&plugin.ClientConfig{
			HandshakeConfig: handshakeConfig,
			Plugins:         pluginMap,
			Cmd:             exec.Command(*pluginPath),
		})
		defer c.Kill()

		rpcClient, err := c.Client()

		if err != nil {
			slog.Error(fmt.Sprintf("Failed to connect to plugin: %s", err))
			return
		}

		raw, err := rpcClient.Dispense("plugin")

		if err != nil {
			slog.Error(fmt.Sprintf("Failed to dispense plugin: %s", err))
			return
		}

		provider := raw.(model.ACLProvider)
		providers = append(providers, provider)
	}

	slog.Info("looking up foo.example.com")

	lookupFunc := func(lookup string) {
		for _, p := range providers {
			slog.Info(fmt.Sprintf("Trying '%s' provider ('%s' type) with '%s' domain", p.GetName(), p.GetType(), lookup))
			app, err := p.GetApp(lookup)
			if err != nil {
				slog.Error(fmt.Sprintf("Provider '%s' returned error: %s", p.GetName(), err))
				continue
			}
			if app != nil {
				slog.Info(fmt.Sprintf("Provider '%s' returned app: %s", p.GetName(), app.Config.Domain))
			}
		}

	}

	lookupDomains := []string{"foo.example.com", "bar.example.com", "foobar.example.com", "barfoo.example.com"}

	for _, lookup := range lookupDomains {
		lookupFunc(lookup)
	}

}