8d9b62daf3
This commit implements Phase 2 of the CHORUS Task Execution Engine development plan, providing a comprehensive execution environment abstraction layer with Docker container sandboxing support. ## New Features ### Core Sandbox Interface - Comprehensive ExecutionSandbox interface with isolated task execution - Support for command execution, file I/O, environment management - Resource usage monitoring and sandbox lifecycle management - Standardized error handling with SandboxError types and categories ### Docker Container Sandbox Implementation - Full Docker API integration with secure container creation - Transparent repository mounting with configurable read/write access - Advanced security policies with capability dropping and privilege controls - Comprehensive resource limits (CPU, memory, disk, processes, file handles) - Support for tmpfs mounts, masked paths, and read-only bind mounts - Container lifecycle management with proper cleanup and health monitoring ### Security & Resource Management - Configurable security policies with SELinux, AppArmor, and Seccomp support - Fine-grained capability management with secure defaults - Network isolation options with configurable DNS and proxy settings - Resource monitoring with real-time CPU, memory, and network usage tracking - Comprehensive ulimits configuration for process and file handle limits ### Repository Integration - Seamless repository mounting from local paths to container workspaces - Git configuration support with user credentials and global settings - File inclusion/exclusion patterns for selective repository access - Configurable permissions and ownership for mounted repositories ### Testing Infrastructure - Comprehensive test suite with 60+ test cases covering all functionality - Docker integration tests with Alpine Linux containers (skipped in short mode) - Mock sandbox implementation for unit testing without Docker dependencies - Security policy validation tests with read-only filesystem enforcement - Resource usage monitoring and cleanup verification tests ## Technical Details ### Dependencies Added - github.com/docker/docker v28.4.0+incompatible - Docker API client - github.com/docker/go-connections v0.6.0 - Docker connection utilities - github.com/docker/go-units v0.5.0 - Docker units and formatting - Associated Docker API dependencies for complete container management ### Architecture - Interface-driven design enabling multiple sandbox implementations - Comprehensive configuration structures for all sandbox aspects - Resource usage tracking with detailed metrics collection - Error handling with retryable error classification - Proper cleanup and resource management throughout sandbox lifecycle ### Compatibility - Maintains backward compatibility with existing CHORUS architecture - Designed for future integration with Phase 3 Core Task Execution Engine - Extensible design supporting additional sandbox implementations (VM, process) This Phase 2 implementation provides the foundation for secure, isolated task execution that will be integrated with the AI model providers from Phase 1 in the upcoming Phase 3 development. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
106 lines
2.9 KiB
Go
106 lines
2.9 KiB
Go
//go:build go1.21
|
|
// +build go1.21
|
|
|
|
/*
|
|
Copyright 2023 The logr Authors.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package funcr
|
|
|
|
import (
|
|
"context"
|
|
"log/slog"
|
|
|
|
"github.com/go-logr/logr"
|
|
)
|
|
|
|
var _ logr.SlogSink = &fnlogger{}
|
|
|
|
const extraSlogSinkDepth = 3 // 2 for slog, 1 for SlogSink
|
|
|
|
func (l fnlogger) Handle(_ context.Context, record slog.Record) error {
|
|
kvList := make([]any, 0, 2*record.NumAttrs())
|
|
record.Attrs(func(attr slog.Attr) bool {
|
|
kvList = attrToKVs(attr, kvList)
|
|
return true
|
|
})
|
|
|
|
if record.Level >= slog.LevelError {
|
|
l.WithCallDepth(extraSlogSinkDepth).Error(nil, record.Message, kvList...)
|
|
} else {
|
|
level := l.levelFromSlog(record.Level)
|
|
l.WithCallDepth(extraSlogSinkDepth).Info(level, record.Message, kvList...)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (l fnlogger) WithAttrs(attrs []slog.Attr) logr.SlogSink {
|
|
kvList := make([]any, 0, 2*len(attrs))
|
|
for _, attr := range attrs {
|
|
kvList = attrToKVs(attr, kvList)
|
|
}
|
|
l.AddValues(kvList)
|
|
return &l
|
|
}
|
|
|
|
func (l fnlogger) WithGroup(name string) logr.SlogSink {
|
|
l.startGroup(name)
|
|
return &l
|
|
}
|
|
|
|
// attrToKVs appends a slog.Attr to a logr-style kvList. It handle slog Groups
|
|
// and other details of slog.
|
|
func attrToKVs(attr slog.Attr, kvList []any) []any {
|
|
attrVal := attr.Value.Resolve()
|
|
if attrVal.Kind() == slog.KindGroup {
|
|
groupVal := attrVal.Group()
|
|
grpKVs := make([]any, 0, 2*len(groupVal))
|
|
for _, attr := range groupVal {
|
|
grpKVs = attrToKVs(attr, grpKVs)
|
|
}
|
|
if attr.Key == "" {
|
|
// slog says we have to inline these
|
|
kvList = append(kvList, grpKVs...)
|
|
} else {
|
|
kvList = append(kvList, attr.Key, PseudoStruct(grpKVs))
|
|
}
|
|
} else if attr.Key != "" {
|
|
kvList = append(kvList, attr.Key, attrVal.Any())
|
|
}
|
|
|
|
return kvList
|
|
}
|
|
|
|
// levelFromSlog adjusts the level by the logger's verbosity and negates it.
|
|
// It ensures that the result is >= 0. This is necessary because the result is
|
|
// passed to a LogSink and that API did not historically document whether
|
|
// levels could be negative or what that meant.
|
|
//
|
|
// Some example usage:
|
|
//
|
|
// logrV0 := getMyLogger()
|
|
// logrV2 := logrV0.V(2)
|
|
// slogV2 := slog.New(logr.ToSlogHandler(logrV2))
|
|
// slogV2.Debug("msg") // =~ logrV2.V(4) =~ logrV0.V(6)
|
|
// slogV2.Info("msg") // =~ logrV2.V(0) =~ logrV0.V(2)
|
|
// slogv2.Warn("msg") // =~ logrV2.V(-4) =~ logrV0.V(0)
|
|
func (l fnlogger) levelFromSlog(level slog.Level) int {
|
|
result := -level
|
|
if result < 0 {
|
|
result = 0 // because LogSink doesn't expect negative V levels
|
|
}
|
|
return int(result)
|
|
}
|