Update to use new Makefile and manifest

.gitignore

@@ -27,3 +27,6 @@ webapp/dist
 *.swp
 .DS_Store
 package-lock.json
+
+# VS Code
+.vscode

Makefile

@@ -1,88 +1,169 @@
-.PHONY: build test run clean stop check-style gofmt
+GO ?= $(shell command -v go 2> /dev/null)
+NPM ?= $(shell command -v npm 2> /dev/null)
+CURL ?= $(shell command -v curl 2> /dev/null)
+MANIFEST_FILE ?= plugin.json
+export GO111MODULE=on
 
-check-style: .npminstall gofmt
+# You can include assets this directory into the bundle. This can be e.g. used to include profile pictures.
+ASSETS_DIR ?= assets
+
+# Verify environment, and define PLUGIN_ID, PLUGIN_VERSION, HAS_SERVER and HAS_WEBAPP as needed.
+include build/setup.mk
+
+BUNDLE_NAME ?= $(PLUGIN_ID)-$(PLUGIN_VERSION).tar.gz
+
+## Checks the code style, tests, builds and bundles the plugin.
+all: check-style test dist
+
+## Propagates plugin manifest information into the server/ and webapp/ folders as required.
+.PHONY: apply
+apply:
+	./build/bin/manifest apply
+
+## Runs govet and gofmt against all packages.
+.PHONY: check-style
+check-style: webapp/.npminstall gofmt govet
 	@echo Checking for style guide compliance
 
-	cd webapp && npm run check
+ifneq ($(HAS_WEBAPP),)
+	cd webapp && npm run lint
+endif
 
+## Runs gofmt against all packages.
+.PHONY: gofmt
 gofmt:
-	@echo Running GOFMT
-
+ifneq ($(HAS_SERVER),)
+	@echo Running gofmt
 	@for package in $$(go list ./server/...); do \
 		echo "Checking "$$package; \
 		files=$$(go list -f '{{range .GoFiles}}{{$$.Dir}}/{{.}} {{end}}' $$package); \
 		if [ "$$files" ]; then \
 			gofmt_output=$$(gofmt -d -s $$files 2>&1); \
 			if [ "$$gofmt_output" ]; then \
 				echo "$$gofmt_output"; \
-				echo "gofmt failure"; \
+				echo "Gofmt failure"; \
 				exit 1; \
 			fi; \
 		fi; \
 	done
-	@echo "gofmt success"; \
-
-test: .npminstall
-	@echo Not yet implemented
-
+	@echo Gofmt success
+endif
+
+## Runs govet against all packages.
+.PHONY: govet
+govet:
+ifneq ($(HAS_SERVER),)
+	@echo Running govet
+	@# Workaroung because you can't install binaries without adding them to go.mod 
+	env GO111MODULE=off $(GO) get golang.org/x/tools/go/analysis/passes/shadow/cmd/shadow
+	$(GO) vet ./server/...
+	$(GO) vet -vettool=$(GOPATH)/bin/shadow ./server/...
+	@echo Govet success
+endif
+
+## Builds the server, if it exists, including support for multiple architectures.
+.PHONY: server
+server:
+ifneq ($(HAS_SERVER),)
+	mkdir -p server/dist;
+	cd server && env GOOS=linux GOARCH=amd64 $(GO) build -o dist/plugin-linux-amd64;
+	cd server && env GOOS=darwin GOARCH=amd64 $(GO) build -o dist/plugin-darwin-amd64;
+	cd server && env GOOS=windows GOARCH=amd64 $(GO) build -o dist/plugin-windows-amd64.exe;
+endif
+
+## Ensures NPM dependencies are installed without having to run this all the time.
 webapp/.npminstall:
-	@echo Getting dependencies using npm
-
-	cd webapp && npm install
+ifneq ($(HAS_WEBAPP),)
+	cd webapp && $(NPM) install
 	touch $@
-
-vendor: server/glide.lock
-	cd server && go get github.com/Masterminds/glide
-	cd server && $(shell go env GOPATH)/bin/glide install
-
-dist: webapp/.npminstall vendor plugin.json
-	@echo Building plugin
-
-	# Clean old dist
-	rm -rf dist
-	rm -rf webapp/dist
-	rm -f server/plugin.exe
-
-	# Build and copy files from webapp
-	cd webapp && npm run build
-	mkdir -p dist/jitsi/webapp
-	cp webapp/dist/* dist/jitsi/webapp/
-
-	# Build files from server
-	cd server && go get github.com/mitchellh/gox
-	$(shell go env GOPATH)/bin/gox -osarch='darwin/amd64 linux/amd64 windows/amd64' -output 'dist/intermediate/plugin_{{.OS}}_{{.Arch}}' ./server
-
-	# Copy plugin files
-	cp plugin.json dist/jitsi/
-
-	# Copy server executables & compress plugin
-	mkdir -p dist/jitsi/server
-	mv dist/intermediate/plugin_darwin_amd64 dist/jitsi/server/plugin.exe
-	cd dist && tar -zcvf mattermost-jitsi-plugin-darwin-amd64.tar.gz jitsi/*
-	mv dist/intermediate/plugin_linux_amd64 dist/jitsi/server/plugin.exe
-	cd dist && tar -zcvf mattermost-jitsi-plugin-linux-amd64.tar.gz jitsi/*
-	mv dist/intermediate/plugin_windows_amd64.exe dist/jitsi/server/plugin.exe
-	cd dist && tar -zcvf mattermost-jitsi-plugin-windows-amd64.tar.gz jitsi/*
-
-	# Clean up temp files
-	rm -rf dist/jitsi
-	rm -rf dist/intermediate
-
-	@echo MacOS X plugin built at: dist/mattermost-jitsi-plugin-darwin-amd64.tar.gz
-	@echo Linux plugin built at: dist/mattermost-jitsi-plugin-linux-amd64.tar.gz
-	@echo Windows plugin built at: dist/mattermost-jitsi-plugin-windows-amd64.tar.gz
-
-run: .npminstall
-	@echo Not yet implemented
-
-stop:
-	@echo Not yet implemented
-
+endif
+
+## Builds the webapp, if it exists.
+.PHONY: webapp
+webapp: webapp/.npminstall
+ifneq ($(HAS_WEBAPP),)
+	cd webapp && $(NPM) run build;
+endif
+
+## Generates a tar bundle of the plugin for install.
+.PHONY: bundle
+bundle:
+	rm -rf dist/
+	mkdir -p dist/$(PLUGIN_ID)
+	cp $(MANIFEST_FILE) dist/$(PLUGIN_ID)/
+ifneq ($(wildcard $(ASSETS_DIR)/.),)
+	cp -r $(ASSETS_DIR) dist/$(PLUGIN_ID)/
+endif
+ifneq ($(HAS_PUBLIC),)
+	cp -r public/ dist/$(PLUGIN_ID)/
+endif
+ifneq ($(HAS_SERVER),)
+	mkdir -p dist/$(PLUGIN_ID)/server/dist;
+	cp -r server/dist/* dist/$(PLUGIN_ID)/server/dist/;
+endif
+ifneq ($(HAS_WEBAPP),)
+	mkdir -p dist/$(PLUGIN_ID)/webapp/dist;
+	cp -r webapp/dist/* dist/$(PLUGIN_ID)/webapp/dist/;
+endif
+	cd dist && tar -cvzf $(BUNDLE_NAME) $(PLUGIN_ID)
+
+	@echo plugin built at: dist/$(BUNDLE_NAME)
+
+## Builds and bundles the plugin.
+.PHONY: dist
+dist:	apply server webapp bundle
+
+## Installs the plugin to a (development) server.
+.PHONY: deploy
+deploy: dist
+## It uses the API if appropriate environment variables are defined,
+## or copying the files directly to a sibling mattermost-server directory.
+ifneq ($(and $(MM_SERVICESETTINGS_SITEURL),$(MM_ADMIN_USERNAME),$(MM_ADMIN_PASSWORD),$(CURL)),)
+	@echo "Installing plugin via API"
+	$(eval TOKEN := $(shell curl -i --post301 --location $(MM_SERVICESETTINGS_SITEURL) -X POST $(MM_SERVICESETTINGS_SITEURL)/api/v4/users/login -d '{"login_id": "$(MM_ADMIN_USERNAME)", "password": "$(MM_ADMIN_PASSWORD)"}' | grep Token | cut -f2 -d' ' 2> /dev/null))
+	@curl -s --post301 --location $(MM_SERVICESETTINGS_SITEURL) -H "Authorization: Bearer $(TOKEN)" -X POST $(MM_SERVICESETTINGS_SITEURL)/api/v4/plugins -F "plugin=@dist/$(BUNDLE_NAME)" -F "force=true" > /dev/null && \
+		curl -s --post301 --location $(MM_SERVICESETTINGS_SITEURL) -H "Authorization: Bearer $(TOKEN)" -X POST $(MM_SERVICESETTINGS_SITEURL)/api/v4/plugins/$(PLUGIN_ID)/enable > /dev/null && \
+		echo "OK." || echo "Sorry, something went wrong."
+else ifneq ($(wildcard ../mattermost-server/.*),)
+	@echo "Installing plugin via filesystem. Server restart and manual plugin enabling required"
+	mkdir -p ../mattermost-server/plugins
+	tar -C ../mattermost-server/plugins -zxvf dist/$(BUNDLE_NAME)
+else
+	@echo "No supported deployment method available. Install plugin manually."
+endif
+
+## Runs any lints and unit tests defined for the server and webapp, if they exist.
+.PHONY: test
+test: webapp/.npminstall
+ifneq ($(HAS_SERVER),)
+	$(GO) test -race -v ./server/...
+endif
+ifneq ($(HAS_WEBAPP),)
+	cd webapp && $(NPM) run fix;
+endif
+
+## Creates a coverage report for the server code.
+.PHONY: coverage
+coverage: server/.depensure webapp/.npminstall
+ifneq ($(HAS_SERVER),)
+	$(GO) test -race -coverprofile=server/coverage.txt ./server/...
+	$(GO) tool cover -html=server/coverage.txt
+endif
+
+## Clean removes all build artifacts.
+.PHONY: clean
 clean:
-	@echo Cleaning plugin
-
-	rm -rf dist
-	rm -rf webapp/dist
-	rm -rf webapp/node_modules
-	rm -rf webapp/.npminstall
-	rm -f server/plugin.exe
+	rm -fr dist/
+ifneq ($(HAS_SERVER),)
+	rm -fr server/dist
+endif
+ifneq ($(HAS_WEBAPP),)
+	rm -fr webapp/.npminstall
+	rm -fr webapp/dist
+	rm -fr webapp/node_modules
+endif
+	rm -fr build/bin/
+
+# Help documentatin à la https://marmelab.com/blog/2016/02/29/auto-documented-makefile.html
+help:
+	@cat Makefile | grep -v '\.PHONY' |  grep -v '\help:' | grep -B1 -E '^[a-zA-Z_.-]+:.*' | sed -e "s/:.*//" | sed -e "s/^## //" |  grep -v '\-\-' | sed '1!G;h;$$!d' | awk 'NR%2{printf "\033[36m%-30s\033[0m",$$0;next;}1' | sort

build/.gitignore

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

build/manifest/main.go

@@ -0,0 +1,122 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+
+	"github.com/mattermost/mattermost-server/model"
+	"github.com/pkg/errors"
+)
+
+const pluginIdGoFileTemplate = `package main
+
+var manifest = struct {
+	Id      string
+	Version string
+}{
+	Id:      "%s",
+	Version: "%s",
+}
+`
+
+const pluginIdJsFileTemplate = `export const id = '%s';
+export const version = '%s';
+`
+
+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")
+		}
+
+	case "apply":
+		if err := applyManifest(manifest); err != nil {
+			panic("failed to apply manifest: " + err.Error())
+		}
+
+	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)
+}
+
+// applyManifest propagates the plugin_id into the server and webapp folders, as necessary
+func applyManifest(manifest *model.Manifest) error {
+	if manifest.HasServer() {
+		if err := ioutil.WriteFile(
+			"server/manifest.go",
+			[]byte(fmt.Sprintf(pluginIdGoFileTemplate, manifest.Id, manifest.Version)),
+			0644,
+		); err != nil {
+			return errors.Wrap(err, "failed to write server/manifest.go")
+		}
+	}
+
+	if manifest.HasWebapp() {
+		if err := ioutil.WriteFile(
+			"webapp/src/manifest.js",
+			[]byte(fmt.Sprintf(pluginIdJsFileTemplate, manifest.Id, manifest.Version)),
+			0644,
+		); err != nil {
+			return errors.Wrap(err, "failed to open webapp/src/manifest.js")
+		}
+	}
+
+	return nil
+}