serve: Add rc control for serve commands #4505

This adds the framework for serving. The individual servers will be
added in separate commits.

cmd/serve/rc_test.go

@@ -0,0 +1,180 @@
+package serve
+
+import (
+	"context"
+	"errors"
+	"net"
+	"testing"
+
+	"github.com/rclone/rclone/fs"
+	"github.com/rclone/rclone/fs/rc"
+	"github.com/rclone/rclone/fstest/mockfs"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+type dummyServer struct {
+	addr           *net.TCPAddr
+	shutdownCh     chan struct{}
+	shutdownCalled bool
+}
+
+func (d *dummyServer) Addr() net.Addr {
+	return d.addr
+}
+
+func (d *dummyServer) Shutdown() error {
+	d.shutdownCalled = true
+	close(d.shutdownCh)
+	return nil
+}
+
+func (d *dummyServer) Serve() error {
+	<-d.shutdownCh
+	return nil
+}
+
+func newServer(ctx context.Context, f fs.Fs, in rc.Params) (Handle, error) {
+	return &dummyServer{
+		addr: &net.TCPAddr{
+			IP:   net.IPv4(127, 0, 0, 1),
+			Port: 8080,
+		},
+		shutdownCh: make(chan struct{}),
+	}, nil
+}
+
+func newServerError(ctx context.Context, f fs.Fs, in rc.Params) (Handle, error) {
+	return nil, errors.New("serve error")
+}
+
+func newServerImmediateStop(ctx context.Context, f fs.Fs, in rc.Params) (Handle, error) {
+	h, _ := newServer(ctx, f, in)
+	close(h.(*dummyServer).shutdownCh)
+	return h, nil
+}
+
+func resetGlobals() {
+	serveMu.Lock()
+	defer serveMu.Unlock()
+	serveFns = make(map[string]Fn)
+	servers = make(map[string]*server)
+}
+
+func newTest(t *testing.T) {
+	_, err := fs.Find("mockfs")
+	if err != nil {
+		mockfs.Register()
+	}
+	resetGlobals()
+	t.Cleanup(resetGlobals)
+}
+
+func TestRcStartServeType(t *testing.T) {
+	newTest(t)
+	serveStart := rc.Calls.Get("serve/start")
+
+	in := rc.Params{"fs": ":mockfs:", "type": "nonexistent"}
+	_, err := serveStart.Fn(context.Background(), in)
+	assert.ErrorContains(t, err, "could not find serve type")
+}
+
+func TestRcStartServeFnError(t *testing.T) {
+	newTest(t)
+	serveStart := rc.Calls.Get("serve/start")
+
+	AddRc("error", newServerError)
+	in := rc.Params{"fs": ":mockfs:", "type": "error"}
+	_, err := serveStart.Fn(context.Background(), in)
+	assert.ErrorContains(t, err, "could not start serve")
+}
+
+func TestRcStartImmediateStop(t *testing.T) {
+	newTest(t)
+	serveStart := rc.Calls.Get("serve/start")
+
+	AddRc("immediate", newServerImmediateStop)
+	in := rc.Params{"fs": ":mockfs:", "type": "immediate"}
+	_, err := serveStart.Fn(context.Background(), in)
+	assert.ErrorContains(t, err, "server stopped immediately")
+}
+
+func TestRcStartAndStop(t *testing.T) {
+	newTest(t)
+	serveStart := rc.Calls.Get("serve/start")
+	serveStop := rc.Calls.Get("serve/stop")
+
+	AddRc("dummy", newServer)
+	in := rc.Params{"fs": ":mockfs:", "type": "dummy"}
+
+	out, err := serveStart.Fn(context.Background(), in)
+	require.NoError(t, err)
+	id := out["id"].(string)
+	assert.Contains(t, id, "dummy")
+	assert.Equal(t, 1, len(servers))
+
+	_, err = serveStop.Fn(context.Background(), rc.Params{"id": id})
+	require.NoError(t, err)
+	assert.Equal(t, 0, len(servers))
+}
+
+func TestRcStopNonexistent(t *testing.T) {
+	newTest(t)
+	serveStop := rc.Calls.Get("serve/stop")
+
+	_, err := serveStop.Fn(context.Background(), rc.Params{"id": "nonexistent"})
+	assert.ErrorContains(t, err, "not found")
+}
+
+func TestRcServeTypes(t *testing.T) {
+	newTest(t)
+	serveTypes := rc.Calls.Get("serve/types")
+
+	AddRc("a", newServer)
+	AddRc("c", newServer)
+	AddRc("b", newServer)
+	out, err := serveTypes.Fn(context.Background(), nil)
+	require.NoError(t, err)
+	types := out["types"].([]string)
+	assert.Equal(t, types, []string{"a", "b", "c"})
+}
+
+func TestRcList(t *testing.T) {
+	newTest(t)
+	serveStart := rc.Calls.Get("serve/start")
+	serveList := rc.Calls.Get("serve/list")
+
+	AddRc("dummy", newServer)
+
+	// Start two servers.
+	_, err := serveStart.Fn(context.Background(), rc.Params{"fs": ":mockfs:", "type": "dummy"})
+	require.NoError(t, err)
+
+	_, err = serveStart.Fn(context.Background(), rc.Params{"fs": ":mockfs:", "type": "dummy"})
+	require.NoError(t, err)
+
+	// Check list
+	out, err := serveList.Fn(context.Background(), nil)
+	require.NoError(t, err)
+
+	list := out["list"].([]*server)
+	assert.Equal(t, 2, len(list))
+}
+
+func TestRcStopAll(t *testing.T) {
+	newTest(t)
+	serveStart := rc.Calls.Get("serve/start")
+	serveStopAll := rc.Calls.Get("serve/stopall")
+
+	AddRc("dummy", newServer)
+
+	_, err := serveStart.Fn(context.Background(), rc.Params{"fs": ":mockfs:", "type": "dummy"})
+	require.NoError(t, err)
+	_, err = serveStart.Fn(context.Background(), rc.Params{"fs": ":mockfs:", "type": "dummy"})
+	require.NoError(t, err)
+	assert.Equal(t, 2, len(servers))
+
+	_, err = serveStopAll.Fn(context.Background(), nil)
+	require.NoError(t, err)
+	assert.Equal(t, 0, len(servers))
+}