Refactor Agent (Again)

Dockerfile

@@ -10,7 +10,8 @@ RUN apk add alpine-sdk git \
 # Debug Build
 FROM base as build
 COPY ./cmd /app/cmd
-COPY ./transport /app/transport
+COPY ./api /app/api
+COPY ./agent /app/agent
 COPY ./script /app/script
 RUN go build -tags=debug -o ./build/agent ./cmd/agent
 

agent/agent.go

@@ -0,0 +1,82 @@
+package agent
+
+import (
+	"context"
+	"time"
+
+	"go.uber.org/zap"
+)
+
+// A Sender is responsible for transporting messages to a server.
+type Sender interface {
+	Send(ServerMessageWriter, Message) error
+}
+
+// A Receiver is responsible for handling messages sent by a server.
+type Receiver interface {
+	Receive(MessageWriter, ServerMessage)
+}
+
+// An Agent communicates with server(s) using the configured transport.
+type Agent struct {
+	Receiver
+	Log *zap.Logger
+
+	Transports []Transport
+
+	MaxIdleTime time.Duration
+	lastSend    time.Time
+}
+
+// Send messages to a server using the configured transports. Returns ErrNoTransports if all fail or
+// if none are configured.
+func (agent Agent) Send(w ServerMessageWriter, msg Message) error {
+	// Don't send empty messages unless it has been at least MaxIdleTime since the last send.
+	if msg.IsEmpty() && time.Since(agent.lastSend) <= agent.MaxIdleTime {
+		return nil
+	}
+
+	// Attempt to send using available transports.
+	for _, transport := range agent.Transports {
+		if err := transport.Send(w, msg); err != nil {
+			transport.Log.Error(
+				"Failed to send message using transport",
+				zap.Error(err),
+				zap.Reflect("transport", transport),
+			)
+			continue
+		}
+
+		// When send is successful, update the timestamp
+		agent.lastSend = time.Now()
+
+		// Sleep the transport's interval on success
+		transport.Sleep()
+
+		return nil
+	}
+
+	return ErrNoTransports
+}
+
+// Run the agent, sending agent messages to a server using configured transports.
+func (agent Agent) Run(ctx context.Context) error {
+	agent.Log.Debug("Starting agent execution")
+	var agentMsg Message
+
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		default:
+			var srvMsg ServerMessage
+
+			if err := agent.Send(&srvMsg, agentMsg); err != nil {
+				return err
+			}
+
+			agentMsg = Message{}
+			agent.Receive(&agentMsg, srvMsg)
+		}
+	}
+}

agent/agent_test.go

@@ -0,0 +1,116 @@
+package agent_test
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/kcarretto/paragon/agent"
+
+	gomock "github.com/golang/mock/gomock"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap"
+)
+
+func TestSend(t *testing.T) {
+	logger, err := zap.NewDevelopment()
+	require.NoError(t, err)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	badSender := NewMockSender(ctrl)
+	sender := NewMockSender(ctrl)
+	unusedSender := NewMockSender(ctrl)
+
+	srvMsg := agent.ServerMessage{}
+	agentMsg := agent.Message{}
+	badSender.EXPECT().Send(&srvMsg, agentMsg).Return(errors.New("oops ^_^"))
+	sender.EXPECT().Send(&srvMsg, agentMsg).Return(nil)
+
+	testAgent := &agent.Agent{
+		Log: logger,
+		Transports: []agent.Transport{
+			agent.Transport{
+				Sender: badSender,
+				Log:    logger.Named("transport.bad"),
+				Name:   "Bad Sender",
+			},
+			agent.Transport{
+				Sender: sender,
+				Log:    logger.Named("transport.good"),
+				Name:   "Good Sender",
+			},
+			agent.Transport{
+				Sender: unusedSender,
+				Log:    logger.Named("transport.should_not_see"),
+				Name:   "Unusued Sender",
+			},
+		},
+	}
+	err = testAgent.Send(&srvMsg, agentMsg)
+	require.NoError(t, err)
+}
+
+func TestAgentRun(t *testing.T) {
+	logger, err := zap.NewDevelopment()
+	require.NoError(t, err)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	sender := NewMockSender(ctrl)
+	recv := NewMockReceiver(ctrl)
+
+	sender.EXPECT().Send(gomock.Not(gomock.Nil()), agent.Message{}).Return(nil).AnyTimes()
+	recv.EXPECT().Receive(gomock.Not(gomock.Nil()), agent.ServerMessage{}).AnyTimes()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Millisecond)
+	defer cancel()
+
+	testAgent := &agent.Agent{
+		Log:         logger,
+		Receiver:    recv,
+		MaxIdleTime: time.Second * 1,
+		Transports: []agent.Transport{
+			agent.Transport{
+				Sender: sender,
+				Log:    logger.Named("transport"),
+				Name:   "Test Sender",
+			},
+		},
+	}
+	err = testAgent.Run(ctx)
+	require.True(t, errors.Is(err, context.DeadlineExceeded), "Unexpected error: %v", err)
+}
+
+func TestRunErrNoTransport(t *testing.T) {
+	logger, err := zap.NewDevelopment()
+	require.NoError(t, err)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	srvMsg := agent.ServerMessage{}
+	agentMsg := agent.Message{}
+	badSender := NewMockSender(ctrl)
+	badSender.EXPECT().Send(&srvMsg, agentMsg).Return(errors.New("oops ^_^"))
+
+	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Millisecond)
+	defer cancel()
+
+	testAgent := &agent.Agent{
+		Log: logger,
+		Transports: []agent.Transport{
+			agent.Transport{
+				Sender: badSender,
+				Log:    logger.Named("transport.bad"),
+				Name:   "Bad Sender",
+			},
+		},
+	}
+
+	err = testAgent.Run(ctx)
+	require.True(t, errors.Is(err, agent.ErrNoTransports), "Unexpected error: %v", err)
+}

transport/debug/html.go → agent/debug/html.go

@@ -32,7 +32,7 @@ const debugHTML = `<!DOCTYPE html>
       "showMethod": "fadeIn",
       "hideMethod": "fadeOut"
 	}
-    
+
 	function addToResults(result) {
     	$('#resultsList').prepend(
     		$('<li class="list-group-item">').append(
@@ -45,7 +45,7 @@ const debugHTML = `<!DOCTYPE html>
     }
     function queueScript(){
     	let script = {
-            "content": btoa($("#scriptTextArea").val())
+            "content": $("#scriptTextArea").val()
         }
         $.ajax({
             url: '/queue',
@@ -70,7 +70,8 @@ const debugHTML = `<!DOCTYPE html>
             	if (response.results != null){
                     response.results.map(function(result){
                         if (result.output != null){
-                            addToResults(atob(result.output));
+							output = result.output.join("\n")
+                            addToResults(output);
                         } else if (result.error != "") {
 							addToResults("error: "+result.error)
 						} else {