add loop-test-plugin

loop-test-plugin/build/.gitignore

@@ -0,0 +1 @@
+bin

loop-test-plugin/build/custom.mk

@@ -0,0 +1 @@
+# Include custom targets and environment variables here

loop-test-plugin/build/legacy.mk

@@ -0,0 +1,3 @@
+.PHONY: apply
+apply:
+	@echo make apply is deprecated and has no effect.

loop-test-plugin/build/manifest/main.go

@@ -0,0 +1,76 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/pkg/errors"
+)
+
+func main() {
+	if len(os.Args) <= 1 {
+		panic("no cmd specified")
+	}
+
+	manifest, err := findManifest()
+	if err != nil {
+		panic("failed to find manifest: " + err.Error())
+	}
+
+	cmd := os.Args[1]
+	switch cmd {
+	case "id":
+		dumpPluginID(manifest)
+
+	case "version":
+		dumpPluginVersion(manifest)
+
+	case "has_server":
+		if manifest.HasServer() {
+			fmt.Printf("true")
+		}
+
+	case "has_webapp":
+		if manifest.HasWebapp() {
+			fmt.Printf("true")
+		}
+
+	default:
+		panic("unrecognized command: " + cmd)
+	}
+}
+
+func findManifest() (*model.Manifest, error) {
+	_, manifestFilePath, err := model.FindManifest(".")
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to find manifest in current working directory")
+	}
+	manifestFile, err := os.Open(manifestFilePath)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to open %s", manifestFilePath)
+	}
+	defer manifestFile.Close()
+
+	// Re-decode the manifest, disallowing unknown fields. When we write the manifest back out,
+	// we don't want to accidentally clobber anything we won't preserve.
+	var manifest model.Manifest
+	decoder := json.NewDecoder(manifestFile)
+	decoder.DisallowUnknownFields()
+	if err = decoder.Decode(&manifest); err != nil {
+		return nil, errors.Wrap(err, "failed to parse manifest")
+	}
+
+	return &manifest, nil
+}
+
+// dumpPluginId writes the plugin id from the given manifest to standard out
+func dumpPluginID(manifest *model.Manifest) {
+	fmt.Printf("%s", manifest.Id)
+}
+
+// dumpPluginVersion writes the plugin version from the given manifest to standard out
+func dumpPluginVersion(manifest *model.Manifest) {
+	fmt.Printf("%s", manifest.Version)
+}

loop-test-plugin/build/pluginctl/main.go

@@ -0,0 +1,177 @@
+// main handles deployment of the plugin to a development server using the Client4 API.
+package main
+
+import (
+	"errors"
+	"fmt"
+	"golang.org/x/net/context"
+	"log"
+	"net"
+	"os"
+
+	"github.com/mattermost/mattermost/server/public/model"
+)
+
+const helpText = `
+Usage:
+    pluginctl deploy <plugin id> <bundle path>
+    pluginctl disable <plugin id>
+    pluginctl enable <plugin id>
+    pluginctl reset <plugin id>
+`
+
+var ctx context.Context
+
+func main() {
+	ctx = context.Background()
+	err := pluginctl()
+	if err != nil {
+		fmt.Printf("Failed: %s\n", err.Error())
+		fmt.Print(helpText)
+		os.Exit(1)
+	}
+}
+
+func pluginctl() error {
+	if len(os.Args) < 3 {
+		return errors.New("invalid number of arguments")
+	}
+
+	client, err := getClient()
+	if err != nil {
+		return err
+	}
+
+	switch os.Args[1] {
+	case "deploy":
+		if len(os.Args) < 4 {
+			return errors.New("invalid number of arguments")
+		}
+		return deploy(client, os.Args[2], os.Args[3])
+	case "disable":
+		return disablePlugin(client, os.Args[2])
+	case "enable":
+		return enablePlugin(client, os.Args[2])
+	case "reset":
+		return resetPlugin(client, os.Args[2])
+	default:
+		return errors.New("invalid second argument")
+	}
+}
+
+func getClient() (*model.Client4, error) {
+	socketPath := os.Getenv("MM_LOCALSOCKETPATH")
+	if socketPath == "" {
+		socketPath = model.LocalModeSocketPath
+	}
+
+	client, connected := getUnixClient(socketPath)
+	if connected {
+		log.Printf("Connecting using local mode over %s", socketPath)
+		return client, nil
+	}
+
+	if os.Getenv("MM_LOCALSOCKETPATH") != "" {
+		log.Printf("No socket found at %s for local mode deployment. Attempting to authenticate with credentials.", socketPath)
+	}
+
+	siteURL := os.Getenv("MM_SERVICESETTINGS_SITEURL")
+	adminToken := os.Getenv("MM_ADMIN_TOKEN")
+	adminUsername := os.Getenv("MM_ADMIN_USERNAME")
+	adminPassword := os.Getenv("MM_ADMIN_PASSWORD")
+
+	if siteURL == "" {
+		return nil, errors.New("MM_SERVICESETTINGS_SITEURL is not set")
+	}
+
+	client = model.NewAPIv4Client(siteURL)
+
+	if adminToken != "" {
+		log.Printf("Authenticating using token against %s.", siteURL)
+		client.SetToken(adminToken)
+		return client, nil
+	}
+
+	if adminUsername != "" && adminPassword != "" {
+		client := model.NewAPIv4Client(siteURL)
+		log.Printf("Authenticating as %s against %s.", adminUsername, siteURL)
+		_, _, err := client.Login(ctx, adminUsername, adminPassword)
+		if err != nil {
+			return nil, fmt.Errorf("failed to login as %s: %w", adminUsername, err)
+		}
+
+		return client, nil
+	}
+
+	return nil, errors.New("one of MM_ADMIN_TOKEN or MM_ADMIN_USERNAME/MM_ADMIN_PASSWORD must be defined")
+}
+
+func getUnixClient(socketPath string) (*model.Client4, bool) {
+	_, err := net.Dial("unix", socketPath)
+	if err != nil {
+		return nil, false
+	}
+
+	return model.NewAPIv4SocketClient(socketPath), true
+}
+
+// deploy attempts to upload and enable a plugin via the Client4 API.
+// It will fail if plugin uploads are disabled.
+func deploy(client *model.Client4, pluginID, bundlePath string) error {
+	pluginBundle, err := os.Open(bundlePath)
+	if err != nil {
+		return fmt.Errorf("failed to open %s: %w", bundlePath, err)
+	}
+	defer pluginBundle.Close()
+
+	log.Print("Uploading plugin via API.")
+	_, _, err = client.UploadPluginForced(ctx, pluginBundle)
+	if err != nil {
+		return fmt.Errorf("failed to upload plugin bundle: %s", err.Error())
+	}
+
+	log.Print("Enabling plugin.")
+	_, err = client.EnablePlugin(ctx, pluginID)
+	if err != nil {
+		return fmt.Errorf("failed to enable plugin: %s", err.Error())
+	}
+
+	return nil
+}
+
+// disablePlugin attempts to disable the plugin via the Client4 API.
+func disablePlugin(client *model.Client4, pluginID string) error {
+	log.Print("Disabling plugin.")
+	_, err := client.DisablePlugin(ctx, pluginID)
+	if err != nil {
+		return fmt.Errorf("failed to disable plugin: %w", err)
+	}
+
+	return nil
+}
+
+// enablePlugin attempts to enable the plugin via the Client4 API.
+func enablePlugin(client *model.Client4, pluginID string) error {
+	log.Print("Enabling plugin.")
+	_, err := client.EnablePlugin(ctx, pluginID)
+	if err != nil {
+		return fmt.Errorf("failed to enable plugin: %w", err)
+	}
+
+	return nil
+}
+
+// resetPlugin attempts to reset the plugin via the Client4 API.
+func resetPlugin(client *model.Client4, pluginID string) error {
+	err := disablePlugin(client, pluginID)
+	if err != nil {
+		return err
+	}
+
+	err = enablePlugin(client, pluginID)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

loop-test-plugin/build/setup.mk

@@ -0,0 +1,45 @@
+# Ensure that go is installed. Note that this is independent of whether or not a server is being
+# built, since the build script itself uses go.
+ifeq ($(GO),)
+    $(error "go is not available: see https://golang.org/doc/install")
+endif
+
+# Ensure that the build tools are compiled. Go's caching makes this quick.
+$(shell cd build/manifest && $(GO) build -o ../bin/manifest)
+
+# Ensure that the deployment tools are compiled. Go's caching makes this quick.
+$(shell cd build/pluginctl && $(GO) build -o ../bin/pluginctl)
+
+# Extract the plugin id from the manifest.
+PLUGIN_ID ?= $(shell build/bin/manifest id)
+ifeq ($(PLUGIN_ID),)
+    $(error "Cannot parse id from $(MANIFEST_FILE)")
+endif
+
+# Extract the plugin version from the manifest.
+PLUGIN_VERSION ?= $(shell build/bin/manifest version)
+ifeq ($(PLUGIN_VERSION),)
+    $(error "Cannot parse version from $(MANIFEST_FILE)")
+endif
+
+# Determine if a server is defined in the manifest.
+HAS_SERVER ?= $(shell build/bin/manifest has_server)
+
+# Determine if a webapp is defined in the manifest.
+HAS_WEBAPP ?= $(shell build/bin/manifest has_webapp)
+
+# Determine if a /public folder is in use
+HAS_PUBLIC ?= $(wildcard public/.)
+
+# Determine if the mattermost-utilities repo is present
+HAS_MM_UTILITIES ?= $(wildcard $(MM_UTILITIES_DIR)/.)
+
+# Store the current path for later use
+PWD ?= $(shell pwd)
+
+# Ensure that npm (and thus node) is installed.
+ifneq ($(HAS_WEBAPP),)
+ifeq ($(NPM),)
+    $(error "npm is not available: see https://www.npmjs.com/get-npm")
+endif
+endif