Merge pull request #255 from jumppad-labs/f-http-resource

HTTP resource

Author: eveld

examples/http/main.hcl

@@ -0,0 +1,59 @@
+resource "container" "httpbin" {
+  image {
+    name = "kong/httpbin:0.1.0"
+  }
+
+  port {
+    local = 80
+    host = 80
+  }
+
+  health_check {
+    timeout = "30s"
+
+    http {
+      address = "http://localhost/get"
+      success_codes = [200]
+    }
+  }
+}
+
+resource "http" "get" {
+  method = "GET"
+
+  url = "http://${resource.container.httpbin.container_name}/get"
+
+  headers = {
+    Accept = "application/json"
+  }
+}
+
+resource "http" "post" {
+  method = "POST"
+
+  url = "http://${resource.container.httpbin.container_name}/post"
+
+  payload = jsonencode({
+    foo = "bar"
+  })
+
+  headers = {
+    Accept = "application/json"
+  }
+}
+
+output "get_body" {
+  value = jsondecode(resource.http.get.body)
+}
+
+output "get_status" {
+  value = resource.http.get.status
+}
+
+output "post_body" {
+  value = jsondecode(resource.http.post.body)
+}
+
+output "post_status" {
+  value = resource.http.post.status
+}

pkg/config/resources/http/provider.go

@@ -0,0 +1,101 @@
+package http
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+
+	"github.com/jumppad-labs/hclconfig/types"
+	"github.com/jumppad-labs/jumppad/pkg/clients/logger"
+	sdk "github.com/jumppad-labs/plugin-sdk"
+)
+
+type Provider struct {
+	config *HTTP
+	log    logger.Logger
+	client http.Client
+}
+
+func (p *Provider) Init(cfg types.Resource, l sdk.Logger) error {
+	c, ok := cfg.(*HTTP)
+	if !ok {
+		return fmt.Errorf("unable to initialize provider, resource is not of type HTTP")
+	}
+
+	client := http.Client{
+		Timeout: 10 * time.Second,
+	}
+
+	p.client = client
+	p.config = c
+	p.log = l
+
+	return nil
+}
+
+func (p *Provider) Create(ctx context.Context) error {
+	p.log.Info(fmt.Sprintf("Creating %s", p.config.Metadata().Type), "ref", p.config.Metadata().ID)
+
+	// If a timeout was specified, set it
+	if p.config.Timeout != "" {
+		timeout, err := time.ParseDuration(p.config.Timeout)
+		if err != nil {
+			return err
+		}
+
+		p.client.Timeout = timeout
+	}
+
+	var payload io.Reader
+	if p.config.Method == "POST" {
+		payload = bytes.NewBuffer([]byte(p.config.Payload))
+	}
+
+	// create a http request
+	request, err := http.NewRequest(p.config.Method, p.config.URL, payload)
+	if err != nil {
+		return err
+	}
+
+	// add headers
+	for k, v := range p.config.Headers {
+		request.Header.Add(k, v)
+	}
+
+	// make the request
+	response, err := p.client.Do(request)
+	if err != nil {
+		return err
+	}
+
+	// read the response body
+	body, err := io.ReadAll(response.Body)
+	if err != nil {
+		return err
+	}
+
+	// set the outputs
+	p.config.Status = response.StatusCode
+	p.config.Body = string(body)
+
+	return nil
+}
+
+func (p *Provider) Destroy(ctx context.Context, force bool) error {
+	return nil
+}
+
+func (p *Provider) Lookup() ([]string, error) {
+	return nil, nil
+}
+
+func (p *Provider) Refresh(ctx context.Context) error {
+	return nil
+}
+
+func (p *Provider) Changed() (bool, error) {
+	return false, nil
+}

pkg/config/resources/http/provider_test.go

@@ -0,0 +1,106 @@
+package http
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/jumppad-labs/hclconfig/types"
+	"github.com/jumppad-labs/jumppad/pkg/clients/logger"
+	"github.com/stretchr/testify/require"
+)
+
+func setupHttp(t *testing.T) (*HTTP, *Provider) {
+	h := &HTTP{ResourceBase: types.ResourceBase{Meta: types.Meta{Name: "test"}}}
+
+	p := &Provider{h, logger.NewTestLogger(t), *http.DefaultClient}
+
+	return h, p
+}
+
+func TestHttpResourceGet(t *testing.T) {
+	expected := "your response"
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprint(w, expected)
+	}))
+
+	defer ts.Close()
+
+	h, p := setupHttp(t)
+	h.Method = "GET"
+	h.URL = ts.URL
+
+	err := p.Create(context.Background())
+	require.NoError(t, err)
+
+	require.Equal(t, 200, h.Status)
+	require.Equal(t, expected, h.Body)
+}
+
+func TestHttpResourcePost(t *testing.T) {
+	var body string
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		data, err := io.ReadAll(r.Body)
+		require.NoError(t, err)
+
+		body = string(data)
+	}))
+
+	defer ts.Close()
+
+	h, p := setupHttp(t)
+	h.Method = "POST"
+	h.URL = ts.URL
+	h.Payload = "your request"
+
+	err := p.Create(context.Background())
+	require.NoError(t, err)
+
+	require.Equal(t, 200, h.Status)
+	require.Equal(t, h.Payload, body)
+}
+
+func TestHttpResourceHeaders(t *testing.T) {
+	headers := map[string]string{}
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		headers["X-First"] = r.Header.Get("X-First")
+		headers["X-Second"] = r.Header.Get("X-Second")
+	}))
+
+	defer ts.Close()
+
+	h, p := setupHttp(t)
+	h.Method = "POST"
+	h.URL = ts.URL
+	h.Headers = map[string]string{
+		"X-First":  "first",
+		"X-Second": "second",
+	}
+
+	err := p.Create(context.Background())
+	require.NoError(t, err)
+
+	require.Equal(t, 200, h.Status)
+	require.Equal(t, h.Headers, headers)
+}
+
+func TestHttpResourceTimeout(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// do nothing
+		time.Sleep(10 * time.Second)
+	}))
+
+	defer ts.Close()
+
+	h, p := setupHttp(t)
+	h.Method = "GET"
+	h.URL = ts.URL
+	h.Timeout = "5s"
+
+	err := p.Create(context.Background())
+	require.Error(t, err)
+}

pkg/config/resources/http/resource.go

@@ -0,0 +1,38 @@
+package http
+
+import (
+	"github.com/jumppad-labs/hclconfig/types"
+	"github.com/jumppad-labs/jumppad/pkg/config"
+)
+
+const TypeHTTP string = "http"
+
+type HTTP struct {
+	types.ResourceBase `hcl:",remain"`
+
+	Method string `hcl:"method" json:"method"`
+	URL    string `hcl:"url" json:"url"`
+
+	Headers map[string]string `hcl:"headers,optional" json:"headers,omitempty"`
+	Payload string            `hcl:"payload,optional" json:"payload,omitempty"`
+	Timeout string            `hcl:"timeout,optional" json:"timeout,omitempty"`
+
+	// Output parameters
+	Status int    `hcl:"status,optional" json:"status"`
+	Body   string `hcl:"body,optional" json:"body"`
+}
+
+func (t *HTTP) Process() error {
+	cfg, err := config.LoadState()
+	if err == nil {
+		// try and find the resource in the state
+		r, _ := cfg.FindResource(t.Meta.ID)
+		if r != nil {
+			state := r.(*HTTP)
+			t.Status = state.Status
+			t.Body = state.Body
+		}
+	}
+
+	return nil
+}

pkg/jumppad/init.go

@@ -13,6 +13,7 @@ import (
 	"github.com/jumppad-labs/jumppad/pkg/config/resources/docs"
 	"github.com/jumppad-labs/jumppad/pkg/config/resources/exec"
 	"github.com/jumppad-labs/jumppad/pkg/config/resources/helm"
+	"github.com/jumppad-labs/jumppad/pkg/config/resources/http"
 	"github.com/jumppad-labs/jumppad/pkg/config/resources/ingress"
 	"github.com/jumppad-labs/jumppad/pkg/config/resources/k8s"
 	"github.com/jumppad-labs/jumppad/pkg/config/resources/network"
@@ -39,6 +40,7 @@ func init() {
 	config.RegisterResource(docs.TypeBook, &docs.Book{}, &null.Provider{})
 	config.RegisterResource(exec.TypeExec, &exec.Exec{}, &exec.Provider{})
 	config.RegisterResource(helm.TypeHelm, &helm.Helm{}, &helm.Provider{})
+	config.RegisterResource(http.TypeHTTP, &http.HTTP{}, &http.Provider{})
 	config.RegisterResource(ingress.TypeIngress, &ingress.Ingress{}, &ingress.Provider{})
 	config.RegisterResource(k8s.TypeK8sCluster, &k8s.Cluster{}, &k8s.ClusterProvider{})
 	config.RegisterResource(k8s.TypeK8sConfig, &k8s.Config{}, &k8s.ConfigProvider{})