cep/executor/network.go

package executor

import (
	"fmt"
	"net/netip"

	fw "git.buran.team/main/fairwind"

	dockerpkg "git.buran.team/main/cep/docker"
)

type Host struct {
	Name string
	IP   string
}

type Network struct {
	global  *Global
	network *dockerpkg.Network
	hosts   []Host
}

func NewNetwork(global *Global, ticket *Ticket, hosts []Host) (*Network, error) {
	cidr, err := networkCIDR(ticket.Index)
	if err != nil {
		global.Log.Information("can't create network", fw.LogError(err))
		return nil, err
	}

	gateway, err := networkGateway(ticket.Index)
	if err != nil {
		global.Log.Information("can't create network", fw.LogError(err))
		return nil, err
	}

	network := dockerpkg.NewNetwork(
		global.Ctx,
		global.Log,
		global.Docker,
		networkName(
			ticket.Index,
		),
		cidr,
		gateway,
	)

	return &Network{
		global:  global,
		network: network,
		hosts:   hosts,
	}, nil
}

func (this *Network) Create() error {
	return this.network.Create()
}

func (this *Network) Delete() error {
	return this.network.Delete()
}

func (this *Network) Network() *dockerpkg.Network {
	return this.network
}

func (this *Network) Hosts() []Host {
	return this.hosts
}

func networkName(index int) string {
	return fmt.Sprintf("network-%d", index)
}

func networkCIDR(index int) (netip.Prefix, error) {
	prefix, err := netip.ParsePrefix(fmt.Sprintf("172.16.%d.0/24", index))
	if err != nil {
		return netip.Prefix{}, fmt.Errorf("can't parse prefix: %w", err)
	}

	return prefix, nil
}

func networkGateway(index int) (netip.Addr, error) {
	address, err := netip.ParseAddr(fmt.Sprintf("172.16.%d.1", index))
	if err != nil {
		return netip.Addr{}, fmt.Errorf("can't parse address: %w", err)
	}

	return address, nil
}