Initial commit

Author: jquirke

.gitignore

@@ -0,0 +1,2 @@
+vendor/
+jdwpgo

Gopkg.lock

@@ -0,0 +1,38 @@
+# Gopkg.toml example
+#
+# Refer to https://golang.github.io/dep/docs/Gopkg.toml.html
+# for detailed Gopkg.toml documentation.
+#
+# required = ["github.com/user/thing/cmd/thing"]
+# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
+#
+# [[constraint]]
+#   name = "github.com/user/project"
+#   version = "1.0.0"
+#
+# [[constraint]]
+#   name = "github.com/user/project2"
+#   branch = "dev"
+#   source = "github.com/myfork/project2"
+#
+# [[override]]
+#   name = "github.com/x/y"
+#   version = "2.4.0"
+#
+# [prune]
+#   non-go = false
+#   go-tests = true
+#   unused-packages = true
+
+
+[prune]
+  go-tests = true
+  unused-packages = true
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/golang-collections/go-datastructures"
+
+[[constraint]]
+  name = "gopkg.in/restruct.v1"
+  version = "1.1.0"

Gopkg.toml

@@ -0,0 +1,9 @@
+package jdwp
+
+// Command represents a command specification
+type Command struct {
+	Commandset     byte
+	Command        byte
+	HasCommandData bool
+	HasReplyData   bool
+}

api/jdwp/command.go

@@ -0,0 +1 @@
+package jdwp

api/jdwp/error.go

@@ -0,0 +1,66 @@
+package debuggercore
+
+import (
+	"encoding/binary"
+	"errors"
+
+	"github.com/jquirke/jdwpgo/api/jdwp"
+	"github.com/jquirke/jdwpgo/jdwpsession"
+	"gopkg.in/restruct.v1"
+)
+
+// DebuggerCore represents an instance of the debugger core
+type DebuggerCore interface {
+	VMCommands() VMCommands
+	ThreadCommands() ThreadCommands
+}
+
+type debuggercore struct {
+	jdwpsession jdwpsession.Session
+}
+
+// NewFromJWDPSession creates a new instance of a debugger core
+// attached to a JWDP session
+func NewFromJWDPSession(session jdwpsession.Session) DebuggerCore {
+	core := &debuggercore{
+		jdwpsession: session,
+	}
+
+	return core
+}
+
+func (d *debuggercore) VMCommands() VMCommands {
+	return d
+}
+
+func (d *debuggercore) ThreadCommands() ThreadCommands {
+	return d
+}
+
+func (d *debuggercore) processCommand(cmd jdwp.Command, requestStruct interface{}, replyStruct interface{}) error {
+	commandPacket := &jdwpsession.CommandPacket{
+		Commandset: cmd.Commandset,
+		Command:    cmd.Command,
+	}
+	var err error
+	if cmd.HasCommandData {
+		commandPacket.Data, err = restruct.Pack(binary.BigEndian, requestStruct)
+		if err != nil {
+			return err
+		}
+	}
+	// TODO implement timeout
+
+	replyCh := d.jdwpsession.SendCommand(commandPacket)
+
+	reply, ok := <-replyCh
+	if !ok {
+		return errors.New("Channel closed")
+	}
+	// TODO handle protocol returned err
+
+	if cmd.HasReplyData {
+		err = restruct.Unpack(reply.Data, binary.BigEndian, replyStruct)
+	}
+	return err
+}

debuggercore/debuggercore.go

@@ -0,0 +1,25 @@
+package debuggercore
+
+import (
+	"github.com/jquirke/jdwpgo/protocol/basetypes"
+	"github.com/jquirke/jdwpgo/protocol/common"
+	"github.com/jquirke/jdwpgo/protocol/thread"
+)
+
+// ThreadCommands expose the ThreadCommands commands
+type ThreadCommands interface {
+	// Basics
+	Name(common.ThreadID) (basetypes.JDWPString, error)
+}
+
+func (d *debuggercore) Name(threadID common.ThreadID) (basetypes.JDWPString, error) {
+	nameCommandData := &thread.NameCommandData{
+		ThreadID: threadID,
+	}
+	var nameReply thread.NameReply
+	err := d.processCommand(thread.NameCommand, nameCommandData, &nameReply)
+	if err != nil {
+		return basetypes.EmptyJWDPString(), err
+	}
+	return nameReply.ThreadName, nil
+}

debuggercore/thread.go

@@ -0,0 +1,131 @@
+package debuggercore
+
+import (
+	"github.com/jquirke/jdwpgo/protocol/vm"
+)
+
+// VMCommands expose the VM commands
+type VMCommands interface {
+	// Class
+	AllClasses() (*vm.AllClassReply, error)
+	// Thread ops
+	AllThreads() (*vm.AllThreadsReply, error)
+	TopLevelThreadGroups() (*vm.TopLevelThreadGroupsReply, error)
+	// Bootstrap
+	Version() (*vm.VersionReply, error)
+	IDSizes() (*vm.IDSizesReply, error)
+	Capabilities() (*vm.CapabilitiesReply, error)
+	CapabilitiesNew() (*vm.CapabilitiesNewReply, error)
+	//Control
+	Suspend() error
+	Resume() error
+	HoldEvents() error
+	ReleaseEvents() error
+	Exit(int32) error
+}
+
+func (d *debuggercore) Version() (*vm.VersionReply, error) {
+	var versionReply vm.VersionReply
+	err := d.processCommand(vm.VersionCommand, nil, &versionReply)
+	if err != nil {
+		return nil, err
+	}
+	return &versionReply, nil
+}
+
+func (d *debuggercore) AllClasses() (*vm.AllClassReply, error) {
+	var allclassesReply vm.AllClassReply
+	err := d.processCommand(vm.AllClassesCommand, nil, &allclassesReply)
+	if err != nil {
+		return nil, err
+	}
+	return &allclassesReply, nil
+}
+
+func (d *debuggercore) AllThreads() (*vm.AllThreadsReply, error) {
+	var allthreadsReply vm.AllThreadsReply
+	err := d.processCommand(vm.AllThreadsCommand, nil, &allthreadsReply)
+	if err != nil {
+		return nil, err
+	}
+	return &allthreadsReply, nil
+}
+
+func (d *debuggercore) TopLevelThreadGroups() (*vm.TopLevelThreadGroupsReply, error) {
+	var topLevelThreadGroupsReply vm.TopLevelThreadGroupsReply
+	err := d.processCommand(vm.TopLevelThreadGroupsCommand, nil, &topLevelThreadGroupsReply)
+	if err != nil {
+		return nil, err
+	}
+	return &topLevelThreadGroupsReply, nil
+}
+
+func (d *debuggercore) IDSizes() (*vm.IDSizesReply, error) {
+	var idsizesReply vm.IDSizesReply
+	err := d.processCommand(vm.IDSizesCommand, nil, &idsizesReply)
+	if err != nil {
+		return nil, err
+	}
+	return &idsizesReply, nil
+}
+
+func (d *debuggercore) Capabilities() (*vm.CapabilitiesReply, error) {
+	var capsReply vm.CapabilitiesReply
+	err := d.processCommand(vm.CapabilitiesCommand, nil, &capsReply)
+	if err != nil {
+		return nil, err
+	}
+	return &capsReply, nil
+}
+
+func (d *debuggercore) CapabilitiesNew() (*vm.CapabilitiesNewReply, error) {
+	var capsNewReply vm.CapabilitiesNewReply
+	err := d.processCommand(vm.CapabilitiesNewCommand, nil, &capsNewReply)
+	if err != nil {
+		return nil, err
+	}
+	return &capsNewReply, nil
+}
+
+func (d *debuggercore) Suspend() error {
+	err := d.processCommand(vm.SuspendCommand, nil, nil)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (d *debuggercore) Resume() error {
+	err := d.processCommand(vm.ResumeCommand, nil, nil)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (d *debuggercore) HoldEvents() error {
+	err := d.processCommand(vm.HoldEventsCommand, nil, nil)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (d *debuggercore) ReleaseEvents() error {
+	err := d.processCommand(vm.ReleaseEventsCommand, nil, nil)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (d *debuggercore) Exit(code int32) error {
+	exitCommandData := &vm.ExitCommandData{
+		ExitCode: code,
+	}
+	err := d.processCommand(vm.ExitCommand, exitCommandData, nil)
+	if err != nil {
+		return err
+	}
+	return nil
+}