Kyle Isom
f9635578e0
Replace the CoreDNS precursor with a purpose-built authoritative DNS server. Zones and records (A, AAAA, CNAME) are stored in SQLite and managed via synchronized gRPC + REST APIs authenticated through MCIAS. Non-authoritative queries are forwarded to upstream resolvers with in-memory caching. Key components: - DNS server (miekg/dns) with authoritative zone handling and forwarding - gRPC + REST management APIs with MCIAS auth (mcdsl integration) - SQLite storage with CNAME exclusivity enforcement and auto SOA serials - 30 tests covering database CRUD, DNS resolution, and caching Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
135 lines
3.3 KiB
Go
135 lines
3.3 KiB
Go
package grpcserver
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
"google.golang.org/protobuf/types/known/timestamppb"
|
|
|
|
pb "git.wntrmute.dev/kyle/mcns/gen/mcns/v1"
|
|
"git.wntrmute.dev/kyle/mcns/internal/db"
|
|
)
|
|
|
|
type zoneService struct {
|
|
pb.UnimplementedZoneServiceServer
|
|
db *db.DB
|
|
}
|
|
|
|
func (s *zoneService) ListZones(_ context.Context, _ *pb.ListZonesRequest) (*pb.ListZonesResponse, error) {
|
|
zones, err := s.db.ListZones()
|
|
if err != nil {
|
|
return nil, status.Error(codes.Internal, "failed to list zones")
|
|
}
|
|
|
|
resp := &pb.ListZonesResponse{}
|
|
for _, z := range zones {
|
|
resp.Zones = append(resp.Zones, zoneToProto(z))
|
|
}
|
|
return resp, nil
|
|
}
|
|
|
|
func (s *zoneService) GetZone(_ context.Context, req *pb.GetZoneRequest) (*pb.Zone, error) {
|
|
zone, err := s.db.GetZone(req.Name)
|
|
if errors.Is(err, db.ErrNotFound) {
|
|
return nil, status.Error(codes.NotFound, "zone not found")
|
|
}
|
|
if err != nil {
|
|
return nil, status.Error(codes.Internal, "failed to get zone")
|
|
}
|
|
return zoneToProto(*zone), nil
|
|
}
|
|
|
|
func (s *zoneService) CreateZone(_ context.Context, req *pb.CreateZoneRequest) (*pb.Zone, error) {
|
|
refresh := int(req.Refresh)
|
|
if refresh == 0 {
|
|
refresh = 3600
|
|
}
|
|
retry := int(req.Retry)
|
|
if retry == 0 {
|
|
retry = 600
|
|
}
|
|
expire := int(req.Expire)
|
|
if expire == 0 {
|
|
expire = 86400
|
|
}
|
|
minTTL := int(req.MinimumTtl)
|
|
if minTTL == 0 {
|
|
minTTL = 300
|
|
}
|
|
|
|
zone, err := s.db.CreateZone(req.Name, req.PrimaryNs, req.AdminEmail, refresh, retry, expire, minTTL)
|
|
if errors.Is(err, db.ErrConflict) {
|
|
return nil, status.Error(codes.AlreadyExists, err.Error())
|
|
}
|
|
if err != nil {
|
|
return nil, status.Error(codes.Internal, "failed to create zone")
|
|
}
|
|
return zoneToProto(*zone), nil
|
|
}
|
|
|
|
func (s *zoneService) UpdateZone(_ context.Context, req *pb.UpdateZoneRequest) (*pb.Zone, error) {
|
|
refresh := int(req.Refresh)
|
|
if refresh == 0 {
|
|
refresh = 3600
|
|
}
|
|
retry := int(req.Retry)
|
|
if retry == 0 {
|
|
retry = 600
|
|
}
|
|
expire := int(req.Expire)
|
|
if expire == 0 {
|
|
expire = 86400
|
|
}
|
|
minTTL := int(req.MinimumTtl)
|
|
if minTTL == 0 {
|
|
minTTL = 300
|
|
}
|
|
|
|
zone, err := s.db.UpdateZone(req.Name, req.PrimaryNs, req.AdminEmail, refresh, retry, expire, minTTL)
|
|
if errors.Is(err, db.ErrNotFound) {
|
|
return nil, status.Error(codes.NotFound, "zone not found")
|
|
}
|
|
if err != nil {
|
|
return nil, status.Error(codes.Internal, "failed to update zone")
|
|
}
|
|
return zoneToProto(*zone), nil
|
|
}
|
|
|
|
func (s *zoneService) DeleteZone(_ context.Context, req *pb.DeleteZoneRequest) (*pb.DeleteZoneResponse, error) {
|
|
err := s.db.DeleteZone(req.Name)
|
|
if errors.Is(err, db.ErrNotFound) {
|
|
return nil, status.Error(codes.NotFound, "zone not found")
|
|
}
|
|
if err != nil {
|
|
return nil, status.Error(codes.Internal, "failed to delete zone")
|
|
}
|
|
return &pb.DeleteZoneResponse{}, nil
|
|
}
|
|
|
|
func zoneToProto(z db.Zone) *pb.Zone {
|
|
return &pb.Zone{
|
|
Id: z.ID,
|
|
Name: z.Name,
|
|
PrimaryNs: z.PrimaryNS,
|
|
AdminEmail: z.AdminEmail,
|
|
Refresh: int32(z.Refresh),
|
|
Retry: int32(z.Retry),
|
|
Expire: int32(z.Expire),
|
|
MinimumTtl: int32(z.MinimumTTL),
|
|
Serial: z.Serial,
|
|
CreatedAt: parseTimestamp(z.CreatedAt),
|
|
UpdatedAt: parseTimestamp(z.UpdatedAt),
|
|
}
|
|
}
|
|
|
|
func parseTimestamp(s string) *timestamppb.Timestamp {
|
|
// SQLite stores as "2006-01-02T15:04:05Z".
|
|
t, err := parseTime(s)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
return timestamppb.New(t)
|
|
}
|