# Main Go Files in the Dewy Repository: A Complete Source Code Guide

> Explore the main Go files in the Dewy repository. Understand the core code structuring CLI, config, and container runtime abstraction. Discover essential files like main.go, dewy.go, and config.go.

- Repository: [Tomohisa Oda/dewy](https://github.com/linyows/dewy)
- Tags: source-code-guide
- Published: 2026-03-06

---

**The Dewy repository contains approximately 20 core Go files organized into packages for CLI entry points, configuration, container runtime abstraction, artifact fetching, registry communication, and caching, with [`cmd/dewy/main.go`](https://github.com/linyows/dewy/blob/main/cmd/dewy/main.go), [`dewy.go`](https://github.com/linyows/dewy/blob/main/dewy.go), and [`config.go`](https://github.com/linyows/dewy/blob/main/config.go) serving as the primary orchestration layer.**

The `linyows/dewy` repository implements a self-updating Go service capable of deploying binaries or containers while maintaining artifact caches and exposing administrative APIs. Understanding the main Go files in the Dewy repository is essential for contributors and operators who need to extend functionality or debug deployment workflows.

## Core Entry Points and CLI Structure

The application exposes both a standalone binary interface and a library-style API for embedding.

### cmd/dewy/main.go: The Application Entry Point

The **[`cmd/dewy/main.go`](https://github.com/linyows/dewy/blob/main/cmd/dewy/main.go)** file contains the `main` function that bootstraps the entire application. It constructs a `dewy.Env` object containing stdout, stderr, command-line arguments, and version information, then delegates to `dewy.RunCLI` to initiate execution.

```bash

# Compile & run (the binary built by `go build ./cmd/dewy`)

dewy \
  --registry https://example.com/dewy \
  --command server \
  --port 8080:80 \
  --notify-slack https://hooks.slack.com/services/XXX/YYY/ZZZ

```

### cli.go: Library-Style CLI Wrapper

The **[`cli.go`](https://github.com/linyows/dewy/blob/main/cli.go)** file provides the `RunCLI` function, which serves as the entry point for the library version of the CLI. It wires stdout/stderr, parses arguments, creates the structured logger, and initializes the core `Dewy` object before starting the run loop.

## Central Orchestration and Configuration

These files implement the central `Dewy` struct and its configuration, handling the coordination between artifact fetching, deployment, and health checking.

### dewy.go: The Core Engine

The **[`dewy.go`](https://github.com/linyows/dewy/blob/main/dewy.go)** file defines the `Dewy` struct and implements the `Start`, `Run`, and `RunContainer` methods. This file orchestrates registry queries, artifact downloads, caching, deployment (binary or container), health checks, proxy routing, admin API exposure, and graceful shutdown. It is the primary integration point that wires together the container, artifact, registry, and notifier packages.

```go
package main

import (
	"os"

	"github.com/linyows/dewy"
	"github.com/linyows/dewy/logging"
)

func main() {
	// Build a logger (wrapping slog)
	logger := logging.NewLogger(os.Stdout, logging.LevelInfo)

	// Minimal config – you could load from a file or flags
	cfg := dewy.Config{
		Registry: "https://example.com/dewy",
		Command:  dewy.SERVER,
		PortMappings: []dewy.PortMapping{
			{ProxyPort: 8080, ContainerPort: ptr(80)},
		},
	}

	// Create the core object
	app, err := dewy.New(cfg, logger)
	if err != nil {
		panic(err)
	}

	// Run once (no scheduler) – useful for tests or one‑shot deployments
	if err := app.Run(); err != nil {
		panic(err)
	}
}

// helper to obtain *int
func ptr(v int) *int { return &v }

```

### config.go: Configuration Management

The **[`config.go`](https://github.com/linyows/dewy/blob/main/config.go)** file contains the `Config` struct definition, which holds all flags and options including registry URL, command mode (server or task), container settings, notifier configuration, and port mappings. This configuration is used by both the CLI entry point and the core `Dewy` engine.

## Container Runtime Abstraction

Dewy supports both Docker and Podman runtimes through a unified interface.

### container/docker.go and container/podman.go

The **[`container/docker.go`](https://github.com/linyows/dewy/blob/main/container/docker.go)** and **[`container/podman.go`](https://github.com/linyows/dewy/blob/main/container/podman.go)** files implement the container runtime interface for Docker and Podman respectively. They handle operations such as running containers, stopping them, listing active containers, inspecting images, and executing health checks.

### container/container.go: Shared Interfaces

The **[`container/container.go`](https://github.com/linyows/dewy/blob/main/container/container.go)** file defines shared abstractions, types, and options used by both Docker and Podman implementations, ensuring a consistent API across different container runtimes.

### container/healthcheck.go: Health Monitoring

The **[`container/healthcheck.go`](https://github.com/linyows/dewy/blob/main/container/healthcheck.go)** file implements HTTP health probes against running containers, verifying that deployed services are ready to accept traffic before marking deployments as successful.

## Artifact and Registry Management

These components handle fetching deployment artifacts and communicating with the Dewy registry service.

### artifact/artifact.go and Implementations

The **[`artifact/artifact.go`](https://github.com/linyows/dewy/blob/main/artifact/artifact.go)** file defines the generic artifact downloader interface. Concrete implementations reside in separate files:
- **[`artifact/s3.go`](https://github.com/linyows/dewy/blob/main/artifact/s3.go)** for Amazon S3
- **[`artifact/gs.go`](https://github.com/linyows/dewy/blob/main/artifact/gs.go)** for Google Cloud Storage
- **[`artifact/ghr.go`](https://github.com/linyows/dewy/blob/main/artifact/ghr.go)** for GitHub Releases
- **[`artifact/oci.go`](https://github.com/linyows/dewy/blob/main/artifact/oci.go)** for OCI-compliant registries

### registry/registry.go: Service Communication

The **[`registry/registry.go`](https://github.com/linyows/dewy/blob/main/registry/registry.go)** file implements the gRPC and HTTP client for communicating with the Dewy registry service. It obtains latest release metadata and reports successful deployments. Generated protobuf stubs reside in **`registry/gen/dewy/`**.

## Supporting Infrastructure

Additional packages provide notifications, caching, logging, and server integration.

### notifier/notifier.go: Deployment Notifications

The **[`notifier/notifier.go`](https://github.com/linyows/dewy/blob/main/notifier/notifier.go)** file defines the `Notifier` interface and factory for sending deployment notifications. Built-in implementations include:
- **[`notifier/slack.go`](https://github.com/linyows/dewy/blob/main/notifier/slack.go)** for Slack webhooks
- **[`notifier/mail.go`](https://github.com/linyows/dewy/blob/main/notifier/mail.go)** for email notifications
- **[`notifier/null.go`](https://github.com/linyows/dewy/blob/main/notifier/null.go)** for no-op operation

Any struct implementing the `Notifier` interface can be injected into the configuration for custom notification channels.

```go
type myNotifier struct{ logging.Logger }

func (n *myNotifier) Send(ctx context.Context, msg string) error {
	n.Logger.Info("custom notify", slog.String("msg", msg))
	return nil
}

// Register it in the config
cfg := dewy.Config{
    Notifier: &myNotifier{*logging.NewLogger(os.Stdout, logging.LevelInfo)},
}

```

### kvs/kvs.go: Artifact Caching

The **[`kvs/kvs.go`](https://github.com/linyows/dewy/blob/main/kvs/kvs.go)** file defines the abstract key-value store interface for caching downloaded artifacts. Concrete implementations include:
- **[`kvs/file.go`](https://github.com/linyows/dewy/blob/main/kvs/file.go)** for local disk storage
- **[`kvs/redis.go`](https://github.com/linyows/dewy/blob/main/kvs/redis.go)** for Redis backends
- **[`kvs/consul.go`](https://github.com/linyows/dewy/blob/main/kvs/consul.go)** for Consul integration

### logging/logger.go: Structured Logging

The **[`logging/logger.go`](https://github.com/linyows/dewy/blob/main/logging/logger.go)** file provides a thin wrapper around Go's `slog` package, adding structured fields and helper methods for consistent logging across the application.

### starter.go: Server-Starter Integration

The **[`starter.go`](https://github.com/linyows/dewy/blob/main/starter.go)** file contains integration helpers for `server-starter`, enabling graceful restarts and socket passing in production deployments.

## Summary

- **[`cmd/dewy/main.go`](https://github.com/linyows/dewy/blob/main/cmd/dewy/main.go)** serves as the application entry point, delegating to `dewy.RunCLI` after constructing the environment.
- **[`dewy.go`](https://github.com/linyows/dewy/blob/main/dewy.go)** contains the central `Dewy` struct that orchestrates registry queries, artifact downloads, deployments, and health checks.
- **[`config.go`](https://github.com/linyows/dewy/blob/main/config.go)** defines the configuration structure used by both CLI and core engine.
- **Container abstraction** is implemented in [`container/docker.go`](https://github.com/linyows/dewy/blob/main/container/docker.go), [`container/podman.go`](https://github.com/linyows/dewy/blob/main/container/podman.go), and supporting files for runtime-agnostic operations.
- **Artifact management** uses [`artifact/artifact.go`](https://github.com/linyows/dewy/blob/main/artifact/artifact.go) with concrete implementations for S3, GCS, GitHub Releases, and OCI registries.
- **Registry communication** is handled by [`registry/registry.go`](https://github.com/linyows/dewy/blob/main/registry/registry.go) using gRPC/HTTP protocols.
- **Supporting packages** include `notifier/` for deployment notifications, `kvs/` for artifact caching, `logging/` for structured logs, and [`starter.go`](https://github.com/linyows/dewy/blob/main/starter.go) for server-starter integration.

## Frequently Asked Questions

### What is the purpose of the dewy.go file in the Dewy repository?

The **[`dewy.go`](https://github.com/linyows/dewy/blob/main/dewy.go)** file defines the central `Dewy` struct and implements the primary orchestration logic including the `Start`, `Run`, and `RunContainer` methods. It coordinates interactions between the registry client, artifact fetchers, container runtime, and notification systems, effectively serving as the main control loop for the self-updating deployment engine.

### How does Dewy support both Docker and Podman container runtimes?

Dewy abstracts container operations through the **[`container/container.go`](https://github.com/linyows/dewy/blob/main/container/container.go)** interface, with concrete implementations provided in **[`container/docker.go`](https://github.com/linyows/dewy/blob/main/container/docker.go)** for Docker and **[`container/podman.go`](https://github.com/linyows/dewy/blob/main/container/podman.go)** for Podman. Both implementations expose identical methods for running, stopping, and inspecting containers, allowing the core engine in [`dewy.go`](https://github.com/linyows/dewy/blob/main/dewy.go) to switch between runtimes based on configuration without requiring code changes.

### What storage backends does Dewy support for caching artifacts?

The artifact caching system is defined in **[`kvs/kvs.go`](https://github.com/linyows/dewy/blob/main/kvs/kvs.go)**, which provides a key-value store interface. Concrete implementations include **[`kvs/file.go`](https://github.com/linyows/dewy/blob/main/kvs/file.go)** for local disk storage, **[`kvs/redis.go`](https://github.com/linyows/dewy/blob/main/kvs/redis.go)** for Redis backends, and **[`kvs/consul.go`](https://github.com/linyows/dewy/blob/main/kvs/consul.go)** for Consul integration. This modular design allows operators to choose appropriate storage based on infrastructure requirements, from single-node deployments to distributed clusters.

### How can I extend Dewy to send notifications to a custom service?

You can implement the `Notifier` interface defined in **[`notifier/notifier.go`](https://github.com/linyows/dewy/blob/main/notifier/notifier.go)**, which requires a `Send(context.Context, string) error` method. After implementing your custom notifier struct, inject it into the `Config` struct's `Notifier` field before calling `dewy.New`. The core engine automatically invokes your implementation during deployment events, enabling integration with arbitrary webhook services, message queues, or monitoring systems.