Basic debug support for Gauge API via web server

Author: kashishm

.gitignore

@@ -0,0 +1,3 @@
+.idea/
+bin
+.DS_Store

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "gauge-proto"]
+	path = gauge-proto
+	url = https://github.com/getgauge/gauge-proto

LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Kashish Munjal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,40 @@
+Spider [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+======
+
+Debugger for [Gauge](http://getgauge.io) API started by IDE's.
+
+Installation
+------------
+
+Download the zip file from the [releases](https://github.com/kashishm/spider/releases) and extract it.
+
+Usage
+-----
+Run the binary extracted from the downloaded zip.
+
+Build from Source
+-----------------
+
+### Requirements
+* [Golang](http://golang.org/)
+
+```
+go get github.com/kashishm/spider
+```
+
+### Compiling
+
+```
+go run spider.go
+```
+
+### For cross-platform compilation and Creating distributable
+
+```
+go run build/make.go
+```
+
+License
+-------
+
+Spider is an open-sourced software licensed under the [MIT license](http://opensource.org/licenses/MIT).

build/make.go

@@ -0,0 +1,153 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	"github.com/getgauge/spider/version"
+)
+
+const (
+	CGO_ENABLED = "CGO_ENABLED"
+)
+
+const (
+	distros = "distros"
+	GOARCH  = "GOARCH"
+	GOOS    = "GOOS"
+	X86     = "386"
+	X86_64  = "amd64"
+	DARWIN  = "darwin"
+	LINUX   = "linux"
+	WINDOWS = "windows"
+	bin     = "bin"
+	spider  = "spider"
+)
+
+func main() {
+	compileAcrossPlatforms()
+	createPluginDistro()
+}
+
+func createPluginDistro() {
+	for _, platformEnv := range platformEnvs {
+		setEnv(platformEnv)
+		fmt.Printf("Creating distro for platform => OS:%s ARCH:%s \n", platformEnv[GOOS], platformEnv[GOARCH])
+		createDistro()
+	}
+	log.Printf("Distributables created in directory => %s \n", filepath.Join(bin, distros))
+}
+
+func createDistro() {
+	packageName := fmt.Sprintf("%s-%s-%s.%s", spider, getPluginVersion(), getGOOS(), getArch())
+	os.Mkdir(filepath.Join(bin, distros), 0755)
+	createZipFromUtil(getBinDir(), packageName)
+}
+
+func createZipFromUtil(dir, name string) {
+	wd, err := os.Getwd()
+	if err != nil {
+		panic(err)
+	}
+	os.Chdir(dir)
+	output, err := executeCommand("zip", "-r", filepath.Join("..", distros, name+".zip"), ".")
+	fmt.Println(output)
+	if err != nil {
+		panic(fmt.Sprintf("Failed to zip: %s", err))
+	}
+	os.Chdir(wd)
+}
+
+func runProcess(command string, arg ...string) {
+	cmd := exec.Command(command, arg...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	log.Printf("Execute %v\n", cmd.Args)
+	err := cmd.Run()
+	if err != nil {
+		panic(err)
+	}
+}
+
+func executeCommand(command string, arg ...string) (string, error) {
+	cmd := exec.Command(command, arg...)
+	bytes, err := cmd.Output()
+	return strings.TrimSpace(fmt.Sprintf("%s", bytes)), err
+}
+
+func compileGoPackage() {
+	runProcess("go", "get", "-d", "./...")
+	runProcess("go", "build", "-o", getGaugeExecutablePath(spider))
+}
+
+func getGaugeExecutablePath(file string) string {
+	return filepath.Join(getBinDir(), getExecutableName(file))
+}
+
+func getExecutableName(file string) string {
+	if getGOOS() == "windows" {
+		return file + ".exe"
+	}
+	return file
+}
+
+func getBinDir() string {
+	return filepath.Join(bin, fmt.Sprintf("%s_%s", getGOOS(), getGOARCH()))
+}
+
+func getPluginVersion() string {
+	return version.Version
+}
+
+func setEnv(envVariables map[string]string) {
+	for k, v := range envVariables {
+		os.Setenv(k, v)
+	}
+}
+
+var (
+	platformEnvs = []map[string]string{
+		map[string]string{GOARCH: X86, GOOS: DARWIN, CGO_ENABLED: "0"},
+		map[string]string{GOARCH: X86_64, GOOS: DARWIN, CGO_ENABLED: "0"},
+		map[string]string{GOARCH: X86, GOOS: LINUX, CGO_ENABLED: "0"},
+		map[string]string{GOARCH: X86_64, GOOS: LINUX, CGO_ENABLED: "0"},
+		map[string]string{GOARCH: X86, GOOS: WINDOWS, CGO_ENABLED: "0"},
+		map[string]string{GOARCH: X86_64, GOOS: WINDOWS, CGO_ENABLED: "0"},
+	}
+)
+
+func compileAcrossPlatforms() {
+	for _, platformEnv := range platformEnvs {
+		setEnv(platformEnv)
+		fmt.Printf("Compiling for platform => OS:%s ARCH:%s \n", platformEnv[GOOS], platformEnv[GOARCH])
+		compileGoPackage()
+	}
+}
+
+func getArch() string {
+	if getGOARCH() == X86 {
+		return "x86"
+	}
+	return "x86_64"
+}
+
+func getGOARCH() string {
+	goArch := os.Getenv(GOARCH)
+	if goArch == "" {
+		return runtime.GOARCH
+	}
+	return goArch
+}
+
+func getGOOS() string {
+	goOS := os.Getenv(GOOS)
+	if goOS == "" {
+		return runtime.GOOS
+	}
+	return goOS
+}

debug/api.go

@@ -0,0 +1,78 @@
+package debug
+
+import (
+	"fmt"
+	"net"
+
+	"bytes"
+	"time"
+
+	m "github.com/getgauge/spider/gauge_messages"
+	"github.com/golang/protobuf/proto"
+)
+
+type api struct {
+	connection net.Conn
+}
+
+func newAPI(host string, port string) (*api, error) {
+	c, err := net.Dial("tcp", fmt.Sprintf("%s:%s", host, port))
+	return &api{connection: c}, err
+}
+
+func (a *api) getResponse(message *m.APIMessage) (*m.APIMessage, error) {
+	messageId := time.Now().UnixNano()
+	message.MessageId = messageId
+
+	data, err := proto.Marshal(message)
+	if err != nil {
+		return nil, err
+	}
+	responseBytes, err := a.writeDataAndGetResponse(data)
+	if err != nil {
+		return nil, err
+	}
+	responseMessage := &m.APIMessage{}
+	if err := proto.Unmarshal(responseBytes, responseMessage); err != nil {
+		return nil, err
+	}
+	return responseMessage, err
+}
+
+func (a *api) writeDataAndGetResponse(messageBytes []byte) ([]byte, error) {
+	if err := a.write(messageBytes); err != nil {
+		return nil, err
+	}
+
+	return a.readResponse()
+}
+
+func (a *api) readResponse() ([]byte, error) {
+	buffer := new(bytes.Buffer)
+	data := make([]byte, 8192)
+	for {
+		n, err := a.connection.Read(data)
+		if err != nil {
+			a.connection.Close()
+			return nil, fmt.Errorf("Connection closed [%s] cause: %s", a.connection.RemoteAddr(), err.Error())
+		}
+
+		buffer.Write(data[0:n])
+
+		messageLength, bytesRead := proto.DecodeVarint(buffer.Bytes())
+		if messageLength > 0 && messageLength < uint64(buffer.Len()) {
+			return buffer.Bytes()[bytesRead : messageLength+uint64(bytesRead)], nil
+		}
+	}
+}
+
+func (a *api) write(messageBytes []byte) error {
+	messageLen := proto.EncodeVarint(uint64(len(messageBytes)))
+	data := append(messageLen, messageBytes...)
+	_, err := a.connection.Write(data)
+	return err
+}
+
+func (a *api) close() {
+	a.connection.Close()
+}