Fix logic

Author: ihippik

builder/docker.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"log/slog"
+	"strconv"
 
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/container"
@@ -23,17 +24,17 @@ func NewDocker(logger *slog.Logger, cli *client.Client) *Docker {
 	return &Docker{cli: cli, logger: logger}
 }
 
-// Build builds docker image.
-func (d Docker) Build(ctx context.Context, file string) (string, error) {
-	tar, err := archive.TarWithOptions("infra/", &archive.TarOptions{})
+// ImageBuild builds docker image.
+func (d Docker) ImageBuild(ctx context.Context, dst, name string) (string, error) {
+	tar, err := archive.TarWithOptions(dst, &archive.TarOptions{})
 	if err != nil {
 		return "", fmt.Errorf("failed to create tar: %w", err)
 	}
 
-	tag := "ihippik/go-lambda:v1.0.0"
+	tag := "go-lambda:" + name
 
 	opts := types.ImageBuildOptions{
-		Dockerfile: file,
+		Dockerfile: "Dockerfile",
 		Tags:       []string{tag},
 		Remove:     true,
 	}
@@ -54,8 +55,8 @@ func (d Docker) Build(ctx context.Context, file string) (string, error) {
 	return tag, nil
 }
 
-// Run create and runs docker container.
-func (d Docker) Run(ctx context.Context, image string) error {
+// ContainerCreate creates Docker container.
+func (d Docker) ContainerCreate(ctx context.Context, image string, port int) (string, error) {
 	resp, err := d.cli.ContainerCreate(
 		ctx, &container.Config{
 			Image: image,
@@ -67,7 +68,7 @@ func (d Docker) Run(ctx context.Context, image string) error {
 				"8080/tcp": []nat.PortBinding{
 					{
 						HostIP:   "0.0.0.0",
-						HostPort: "8080",
+						HostPort: strconv.Itoa(port),
 					},
 				},
 			},
@@ -77,16 +78,32 @@ func (d Docker) Run(ctx context.Context, image string) error {
 		"go-lambda",
 	)
 	if err != nil {
-		return fmt.Errorf("failed to create container: %w", err)
+		return "", fmt.Errorf("failed to create container: %w", err)
 	}
 
-	d.logger.Debug("container created", slog.String("id", resp.ID))
+	d.logger.Info("container created", slog.String("id", resp.ID[:5]), slog.Int("port", port))
 
-	if err := d.cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
+	return resp.ID, nil
+}
+
+// ContainerStart starts Docker container.
+func (d Docker) ContainerStart(ctx context.Context, imageID string) error {
+	if err := d.cli.ContainerStart(ctx, imageID, types.ContainerStartOptions{}); err != nil {
 		return fmt.Errorf("failed to start container: %w", err)
 	}
 
-	d.logger.Debug("container started", slog.String("id", resp.ID))
+	d.logger.Debug("container started", slog.String("id", imageID[:5]))
+
+	return nil
+}
+
+// ContainerStop stops Docker container.
+func (d Docker) ContainerStop(ctx context.Context, imageID string) error {
+	if err := d.cli.ContainerStop(ctx, imageID, container.StopOptions{}); err != nil {
+		return fmt.Errorf("failed to stop container: %w", err)
+	}
+
+	d.logger.Debug("container stopped", slog.String("id", imageID[:5]))
 
 	return nil
 }

cmd/lambda-go/main.go

@@ -32,8 +32,8 @@ func main() {
 		return
 	}
 
-	c := builder.NewDocker(logger, cli)
-	svc := lambda.NewService(conf, logger, c)
+	bld := builder.NewDocker(logger, cli)
+	svc := lambda.NewService(conf, logger, bld)
 	edp := lambda.NewEndpoint(svc, logger, conf.App.ServerAddr)
 
 	if err := edp.StartServer(ctx); err != nil {

config/config.go

@@ -14,8 +14,8 @@ type Config struct {
 	App AppCfg      `env:",prefix=APP_,required"`
 }
 
+// AppCfg is a configuration for the application.
 type AppCfg struct {
-	FuncAddr   string `env:"FUNC_ADDR,required"`
 	ServerAddr string `env:"SERVER_ADDR,required"`
 }
 

infra/Dockerfile

@@ -4,10 +4,10 @@ WORKDIR /tmp/server-app
 
 COPY go.mod ./
 COPY go.sum ./
+COPY main.go ./
+RUN go mod tidy
 RUN go mod download
 
-COPY *.go ./
-
 # Build
 RUN CGO_ENABLED=0 GOOS=linux go build -o ./out/server-app .
 

infra/go.mod

@@ -2,6 +2,8 @@ package lambda
 
 import (
 	"context"
+	"encoding/json"
+	"fmt"
 	"io"
 	"log/slog"
 	"net/http"
@@ -11,7 +13,7 @@ import (
 )
 
 type service interface {
-	Create(ctx context.Context, name string) error
+	Create(ctx context.Context, name string, file io.ReadCloser) error
 	Invoke(ctx context.Context, name string, data []byte) ([]byte, error)
 }
 
@@ -27,40 +29,56 @@ func NewEndpoint(svc service, logger *slog.Logger, addr string) *Endpoint {
 	return &Endpoint{svc: svc, logger: logger, serverAddr: addr}
 }
 
-type adminRequest struct {
-	Name string `json:"name"`
+type createResponse struct {
+	Name        string `json:"name"`
+	Description string `json:"description"`
 }
 
+// create http endpoint for create lambda function.
 func (e *Endpoint) create(w http.ResponseWriter, r *http.Request) {
+	const gzHeader = "application/gzip"
 	vars := mux.Vars(r)
 	name := vars["name"]
 
-	// TODO: get tar archive from request body
+	file, fileHeader, err := r.FormFile("file")
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
 
-	//
-	//if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-	//	http.Error(w, err.Error(), http.StatusBadRequest)
-	//	return
-	//}
+	if fileHeader.Header.Get("Content-Type") != gzHeader {
+		http.Error(w, "invalid file type", http.StatusBadRequest)
+		return
+	}
 
-	e.logger.Debug("got create request", slog.Any("user_name", name))
+	e.logger.Info("got create request", slog.Any("func_name", name))
 
-	err := e.svc.Create(r.Context(), name)
-	if err != nil {
+	if err := e.svc.Create(r.Context(), name, file); err != nil {
 		e.logger.Error("create: service error", "err", err.Error())
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
 
-	_, err = w.Write([]byte("ok"))
+	resp := createResponse{Name: name, Description: "lambda function was created"}
+	data, err := json.Marshal(resp)
+	if err != nil {
+		e.logger.Error("create: marshal error", "err", err.Error())
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.WriteHeader(http.StatusCreated)
+
+	_, err = w.Write(data)
 	if err != nil {
 		e.logger.Error("create: write error", "err", err.Error())
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 }
 
-func (e *Endpoint) lambda(w http.ResponseWriter, r *http.Request) {
+// invoke http endpoint for invoke lambda function.
+func (e *Endpoint) invoke(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
 	name := vars["name"]
 
@@ -71,9 +89,9 @@ func (e *Endpoint) lambda(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	e.logger.Debug("got lambda request", slog.Any("user_name", name))
+	e.logger.Info("got lambda request", slog.Any("func_name", name))
 
-	respData, err := e.svc.Invoke(r.Context(), "test", data)
+	respData, err := e.svc.Invoke(r.Context(), name, data)
 	if err != nil {
 		e.logger.Error("lambda: invoke service error", "err", err.Error())
 		http.Error(w, err.Error(), http.StatusBadRequest)
@@ -90,8 +108,8 @@ func (e *Endpoint) lambda(w http.ResponseWriter, r *http.Request) {
 // StartServer starts http-server.
 func (e *Endpoint) StartServer(ctx context.Context) error {
 	r := mux.NewRouter()
-	r.HandleFunc("/lambda/{name}/create", e.create)
-	r.HandleFunc("/lambda/{name}/run", e.lambda)
+	r.HandleFunc("/lambda/{name}/create", e.create).Methods(http.MethodPost)
+	r.HandleFunc("/lambda/{name}/invoke", e.invoke).Methods(http.MethodPost)
 
 	srv := &http.Server{
 		Handler:      r,

infra/go.sum

@@ -0,0 +1,16 @@
+package lambda
+
+import "strconv"
+
+type metaData struct {
+	containerID string
+	port        int
+}
+
+func newMetaData(containerID string, port int) *metaData {
+	return &metaData{containerID: containerID, port: port}
+}
+
+func (m metaData) address() string {
+	return "http://localhost:" + strconv.Itoa(m.port)
+}