@@ -3519,8 +3749,250 @@ func (s *Server) getRepositorySyncLogsHandler(w http.ResponseWriter, r *http.Req
})
}
+// Council management handlers
+
+func (s *Server) getCouncilHandler(w http.ResponseWriter, r *http.Request) {
+ councilIDStr := chi.URLParam(r, "councilID")
+ councilID, err := uuid.Parse(councilIDStr)
+ if err != nil {
+ render.Status(r, http.StatusBadRequest)
+ render.JSON(w, r, map[string]string{"error": "invalid council ID"})
+ return
+ }
+
+ composition, err := s.councilComposer.GetCouncilComposition(r.Context(), councilID)
+ if err != nil {
+ if strings.Contains(err.Error(), "no rows in result set") {
+ render.Status(r, http.StatusNotFound)
+ render.JSON(w, r, map[string]string{"error": "council not found"})
+ return
+ }
+
+ log.Error().Err(err).Str("council_id", councilIDStr).Msg("Failed to get council composition")
+ render.Status(r, http.StatusInternalServerError)
+ render.JSON(w, r, map[string]string{"error": "failed to retrieve council"})
+ return
+ }
+
+ render.JSON(w, r, composition)
+}
+
+func (s *Server) getCouncilArtifactsHandler(w http.ResponseWriter, r *http.Request) {
+ councilIDStr := chi.URLParam(r, "councilID")
+ councilID, err := uuid.Parse(councilIDStr)
+ if err != nil {
+ render.Status(r, http.StatusBadRequest)
+ render.JSON(w, r, map[string]string{"error": "invalid council ID"})
+ return
+ }
+
+ // Query all artifacts for this council
+ query := `
+ SELECT id, artifact_type, artifact_name, content, content_json, produced_at, produced_by, status
+ FROM council_artifacts
+ WHERE council_id = $1
+ ORDER BY produced_at DESC
+ `
+
+ rows, err := s.db.Pool.Query(r.Context(), query, councilID)
+ if err != nil {
+ log.Error().Err(err).Str("council_id", councilIDStr).Msg("Failed to query council artifacts")
+ render.Status(r, http.StatusInternalServerError)
+ render.JSON(w, r, map[string]string{"error": "failed to retrieve artifacts"})
+ return
+ }
+ defer rows.Close()
+
+ var artifacts []map[string]interface{}
+ for rows.Next() {
+ var id uuid.UUID
+ var artifactType, artifactName, status string
+ var content *string
+ var contentJSON []byte
+ var producedAt time.Time
+ var producedBy *string
+
+ err := rows.Scan(&id, &artifactType, &artifactName, &content, &contentJSON, &producedAt, &producedBy, &status)
+ if err != nil {
+ log.Error().Err(err).Msg("Failed to scan artifact row")
+ continue
+ }
+
+ artifact := map[string]interface{}{
+ "id": id,
+ "artifact_type": artifactType,
+ "artifact_name": artifactName,
+ "content": content,
+ "produced_at": producedAt.Format(time.RFC3339),
+ "produced_by": producedBy,
+ "status": status,
+ }
+
+ // Parse JSON content if available
+ if contentJSON != nil {
+ var jsonData interface{}
+ if err := json.Unmarshal(contentJSON, &jsonData); err == nil {
+ artifact["content_json"] = jsonData
+ }
+ }
+
+ artifacts = append(artifacts, artifact)
+ }
+
+ if err = rows.Err(); err != nil {
+ log.Error().Err(err).Msg("Error iterating artifact rows")
+ render.Status(r, http.StatusInternalServerError)
+ render.JSON(w, r, map[string]string{"error": "failed to process artifacts"})
+ return
+ }
+
+ render.JSON(w, r, map[string]interface{}{
+ "council_id": councilID,
+ "artifacts": artifacts,
+ "count": len(artifacts),
+ })
+}
+
+func (s *Server) createCouncilArtifactHandler(w http.ResponseWriter, r *http.Request) {
+ councilIDStr := chi.URLParam(r, "councilID")
+ councilID, err := uuid.Parse(councilIDStr)
+ if err != nil {
+ render.Status(r, http.StatusBadRequest)
+ render.JSON(w, r, map[string]string{"error": "invalid council ID"})
+ return
+ }
+
+ var req struct {
+ ArtifactType string `json:"artifact_type"`
+ ArtifactName string `json:"artifact_name"`
+ Content *string `json:"content,omitempty"`
+ ContentJSON interface{} `json:"content_json,omitempty"`
+ ProducedBy *string `json:"produced_by,omitempty"`
+ Status *string `json:"status,omitempty"`
+ }
+
+ if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+ render.Status(r, http.StatusBadRequest)
+ render.JSON(w, r, map[string]string{"error": "invalid JSON body"})
+ return
+ }
+
+ if req.ArtifactType == "" || req.ArtifactName == "" {
+ render.Status(r, http.StatusBadRequest)
+ render.JSON(w, r, map[string]string{"error": "artifact_type and artifact_name are required"})
+ return
+ }
+
+ // Set default status if not provided
+ status := "draft"
+ if req.Status != nil {
+ status = *req.Status
+ }
+
+ // Validate artifact type (based on the constraint in the migration)
+ validTypes := map[string]bool{
+ "kickoff_manifest": true,
+ "seminal_dr": true,
+ "scaffold_plan": true,
+ "gate_tests": true,
+ "hmmm_thread": true,
+ "slurp_sources": true,
+ "shhh_policy": true,
+ "ucxl_root": true,
+ }
+
+ if !validTypes[req.ArtifactType] {
+ render.Status(r, http.StatusBadRequest)
+ render.JSON(w, r, map[string]string{"error": "invalid artifact_type"})
+ return
+ }
+
+ // Prepare JSON content
+ var contentJSONBytes []byte
+ if req.ContentJSON != nil {
+ contentJSONBytes, err = json.Marshal(req.ContentJSON)
+ if err != nil {
+ render.Status(r, http.StatusBadRequest)
+ render.JSON(w, r, map[string]string{"error": "invalid content_json"})
+ return
+ }
+ }
+
+ // Insert artifact
+ insertQuery := `
+ INSERT INTO council_artifacts (council_id, artifact_type, artifact_name, content, content_json, produced_by, status)
+ VALUES ($1, $2, $3, $4, $5, $6, $7)
+ RETURNING id, produced_at
+ `
+
+ var artifactID uuid.UUID
+ var producedAt time.Time
+
+ err = s.db.Pool.QueryRow(r.Context(), insertQuery, councilID, req.ArtifactType, req.ArtifactName,
+ req.Content, contentJSONBytes, req.ProducedBy, status).Scan(&artifactID, &producedAt)
+
+ if err != nil {
+ log.Error().Err(err).Str("council_id", councilIDStr).Msg("Failed to create council artifact")
+ render.Status(r, http.StatusInternalServerError)
+ render.JSON(w, r, map[string]string{"error": "failed to create artifact"})
+ return
+ }
+
+ response := map[string]interface{}{
+ "id": artifactID,
+ "council_id": councilID,
+ "artifact_type": req.ArtifactType,
+ "artifact_name": req.ArtifactName,
+ "content": req.Content,
+ "content_json": req.ContentJSON,
+ "produced_by": req.ProducedBy,
+ "status": status,
+ "produced_at": producedAt.Format(time.RFC3339),
+ }
+
+ render.Status(r, http.StatusCreated)
+ render.JSON(w, r, response)
+}
+
// Helper methods for task processing
+// lookupProjectData queries the repositories table to find project data by name
+func (s *Server) lookupProjectData(ctx context.Context, projectID string, projectData *struct {
+ RepoURL string `json:"repo_url"`
+ Name string `json:"name"`
+}) error {
+ // Query the repositories table to find the repository by name
+ // We assume projectID corresponds to the repository name
+ query := `
+ SELECT name, url
+ FROM repositories
+ WHERE name = $1 OR full_name LIKE '%/' || $1
+ LIMIT 1
+ `
+
+ var name, url string
+ err := s.db.Pool.QueryRow(ctx, query, projectID).Scan(&name, &url)
+ if err != nil {
+ if strings.Contains(err.Error(), "no rows in result set") {
+ return fmt.Errorf("project %s not found in repositories", projectID)
+ }
+ log.Error().Err(err).Str("project_id", projectID).Msg("Failed to query repository")
+ return fmt.Errorf("database error: %w", err)
+ }
+
+ // Populate the project data
+ projectData.Name = name
+ projectData.RepoURL = url
+
+ log.Info().
+ Str("project_id", projectID).
+ Str("name", name).
+ Str("repo_url", url).
+ Msg("Found project data in repositories table")
+
+ return nil
+}
+
// inferTechStackFromLabels extracts technology information from labels
func (s *Server) inferTechStackFromLabels(labels []string) []string {
techMap := map[string]bool{
@@ -3535,7 +4007,6 @@ func (s *Server) inferTechStackFromLabels(labels []string) []string {
"docker": true,
"postgres": true,
"mysql": true,
- "redis": true,
"api": true,
"backend": true,
"frontend": true,
diff --git a/internal/tracing/tracing.go b/internal/tracing/tracing.go
new file mode 100644
index 0000000..ca7d47b
--- /dev/null
+++ b/internal/tracing/tracing.go
@@ -0,0 +1,152 @@
+package tracing
+
+import (
+ "context"
+ "fmt"
+
+ "go.opentelemetry.io/otel"
+ "go.opentelemetry.io/otel/attribute"
+ "go.opentelemetry.io/otel/codes"
+ "go.opentelemetry.io/otel/exporters/jaeger"
+ "go.opentelemetry.io/otel/propagation"
+ "go.opentelemetry.io/otel/sdk/resource"
+ tracesdk "go.opentelemetry.io/otel/sdk/trace"
+ semconv "go.opentelemetry.io/otel/semconv/v1.24.0"
+ "go.opentelemetry.io/otel/trace"
+
+ "github.com/chorus-services/whoosh/internal/config"
+)
+
+// Tracer is the global tracer for WHOOSH
+var Tracer trace.Tracer
+
+// Initialize sets up OpenTelemetry tracing
+func Initialize(cfg config.OpenTelemetryConfig) (func(), error) {
+ if !cfg.Enabled {
+ // Set up no-op tracer
+ Tracer = otel.Tracer("whoosh")
+ return func() {}, nil
+ }
+
+ // Create Jaeger exporter
+ exp, err := jaeger.New(jaeger.WithCollectorEndpoint(jaeger.WithEndpoint(cfg.JaegerEndpoint)))
+ if err != nil {
+ return nil, fmt.Errorf("failed to create jaeger exporter: %w", err)
+ }
+
+ // Create resource with service information
+ res, err := resource.Merge(
+ resource.Default(),
+ resource.NewWithAttributes(
+ semconv.SchemaURL,
+ semconv.ServiceName(cfg.ServiceName),
+ semconv.ServiceVersion(cfg.ServiceVersion),
+ semconv.DeploymentEnvironment(cfg.Environment),
+ ),
+ )
+ if err != nil {
+ return nil, fmt.Errorf("failed to create resource: %w", err)
+ }
+
+ // Create trace provider
+ tp := tracesdk.NewTracerProvider(
+ tracesdk.WithBatcher(exp),
+ tracesdk.WithResource(res),
+ tracesdk.WithSampler(tracesdk.TraceIDRatioBased(cfg.SampleRate)),
+ )
+
+ // Set global trace provider
+ otel.SetTracerProvider(tp)
+
+ // Set global propagator
+ otel.SetTextMapPropagator(propagation.TraceContext{})
+
+ // Create tracer
+ Tracer = otel.Tracer("whoosh")
+
+ // Return cleanup function
+ cleanup := func() {
+ if err := tp.Shutdown(context.Background()); err != nil {
+ // Log error but don't return it since this is cleanup
+ fmt.Printf("Error shutting down tracer provider: %v\n", err)
+ }
+ }
+
+ return cleanup, nil
+}
+
+// StartSpan creates a new span with the given name and attributes
+func StartSpan(ctx context.Context, name string, opts ...trace.SpanStartOption) (context.Context, trace.Span) {
+ return Tracer.Start(ctx, name, opts...)
+}
+
+// AddAttributes adds attributes to the current span
+func AddAttributes(span trace.Span, attributes ...attribute.KeyValue) {
+ span.SetAttributes(attributes...)
+}
+
+// SetSpanError records an error in the span and sets the status
+func SetSpanError(span trace.Span, err error) {
+ if err != nil {
+ span.RecordError(err)
+ span.SetStatus(codes.Error, err.Error())
+ }
+}
+
+// Common attribute keys for WHOOSH tracing
+var (
+ // Goal and Pulse correlation attributes
+ AttrGoalIDKey = attribute.Key("goal.id")
+ AttrPulseIDKey = attribute.Key("pulse.id")
+
+ // Component attributes
+ AttrComponentKey = attribute.Key("whoosh.component")
+ AttrOperationKey = attribute.Key("whoosh.operation")
+
+ // Resource attributes
+ AttrTaskIDKey = attribute.Key("task.id")
+ AttrCouncilIDKey = attribute.Key("council.id")
+ AttrAgentIDKey = attribute.Key("agent.id")
+ AttrRepositoryKey = attribute.Key("repository.name")
+)
+
+// Convenience functions for creating common spans
+func StartMonitorSpan(ctx context.Context, operation string, repository string) (context.Context, trace.Span) {
+ return StartSpan(ctx, fmt.Sprintf("monitor.%s", operation),
+ trace.WithAttributes(
+ attribute.String("whoosh.component", "monitor"),
+ attribute.String("whoosh.operation", operation),
+ attribute.String("repository.name", repository),
+ ),
+ )
+}
+
+func StartCouncilSpan(ctx context.Context, operation string, councilID string) (context.Context, trace.Span) {
+ return StartSpan(ctx, fmt.Sprintf("council.%s", operation),
+ trace.WithAttributes(
+ attribute.String("whoosh.component", "council"),
+ attribute.String("whoosh.operation", operation),
+ attribute.String("council.id", councilID),
+ ),
+ )
+}
+
+func StartDeploymentSpan(ctx context.Context, operation string, serviceName string) (context.Context, trace.Span) {
+ return StartSpan(ctx, fmt.Sprintf("deployment.%s", operation),
+ trace.WithAttributes(
+ attribute.String("whoosh.component", "deployment"),
+ attribute.String("whoosh.operation", operation),
+ attribute.String("service.name", serviceName),
+ ),
+ )
+}
+
+func StartWebhookSpan(ctx context.Context, operation string, source string) (context.Context, trace.Span) {
+ return StartSpan(ctx, fmt.Sprintf("webhook.%s", operation),
+ trace.WithAttributes(
+ attribute.String("whoosh.component", "webhook"),
+ attribute.String("whoosh.operation", operation),
+ attribute.String("webhook.source", source),
+ ),
+ )
+}
\ No newline at end of file
diff --git a/internal/validation/validator.go b/internal/validation/validator.go
new file mode 100644
index 0000000..71a7a86
--- /dev/null
+++ b/internal/validation/validator.go
@@ -0,0 +1,307 @@
+package validation
+
+import (
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "net/url"
+ "regexp"
+ "strings"
+
+ "github.com/go-chi/render"
+ "github.com/rs/zerolog/log"
+)
+
+// Common validation patterns
+var (
+ // AlphaNumeric allows letters, numbers, hyphens and underscores
+ AlphaNumeric = regexp.MustCompile(`^[a-zA-Z0-9_-]+$`)
+
+ // ProjectName allows alphanumeric, spaces, hyphens, underscores (max 100 chars)
+ ProjectName = regexp.MustCompile(`^[a-zA-Z0-9\s_-]{1,100}$`)
+
+ // GitURL validates basic git URL structure
+ GitURL = regexp.MustCompile(`^https?:\/\/[a-zA-Z0-9.-]+\/[a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+(?:\.git)?$`)
+
+ // TaskTitle allows reasonable task title characters (max 200 chars)
+ TaskTitle = regexp.MustCompile(`^[a-zA-Z0-9\s.,!?()_-]{1,200}$`)
+
+ // AgentID should be alphanumeric with hyphens (max 50 chars)
+ AgentID = regexp.MustCompile(`^[a-zA-Z0-9-]{1,50}$`)
+
+ // UUID pattern for council IDs, task IDs, etc.
+ UUID = regexp.MustCompile(`^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$`)
+)
+
+// ValidationError represents a validation error
+type ValidationError struct {
+ Field string `json:"field"`
+ Message string `json:"message"`
+}
+
+// ValidationErrors is a slice of validation errors
+type ValidationErrors []ValidationError
+
+func (v ValidationErrors) Error() string {
+ if len(v) == 0 {
+ return ""
+ }
+ if len(v) == 1 {
+ return fmt.Sprintf("%s: %s", v[0].Field, v[0].Message)
+ }
+ return fmt.Sprintf("validation failed for %d fields", len(v))
+}
+
+// Validator provides request validation utilities
+type Validator struct {
+ maxBodySize int64
+}
+
+// NewValidator creates a new validator with default settings
+func NewValidator() *Validator {
+ return &Validator{
+ maxBodySize: 1024 * 1024, // 1MB default
+ }
+}
+
+// WithMaxBodySize sets the maximum request body size
+func (v *Validator) WithMaxBodySize(size int64) *Validator {
+ v.maxBodySize = size
+ return v
+}
+
+// DecodeAndValidateJSON safely decodes JSON with size limits and validation
+func (v *Validator) DecodeAndValidateJSON(r *http.Request, dest interface{}) error {
+ // Limit request body size to prevent DoS attacks
+ r.Body = http.MaxBytesReader(nil, r.Body, v.maxBodySize)
+
+ // Decode JSON
+ if err := json.NewDecoder(r.Body).Decode(dest); err != nil {
+ log.Warn().Err(err).Msg("JSON decode error")
+ return fmt.Errorf("invalid JSON: %w", err)
+ }
+
+ return nil
+}
+
+// ValidateProjectRequest validates project creation/update requests
+func ValidateProjectRequest(req map[string]interface{}) ValidationErrors {
+ var errors ValidationErrors
+
+ // Validate name
+ name, ok := req["name"].(string)
+ if !ok || name == "" {
+ errors = append(errors, ValidationError{
+ Field: "name",
+ Message: "name is required",
+ })
+ } else if !ProjectName.MatchString(name) {
+ errors = append(errors, ValidationError{
+ Field: "name",
+ Message: "name contains invalid characters or is too long (max 100 chars)",
+ })
+ }
+
+ // Validate repo_url
+ repoURL, ok := req["repo_url"].(string)
+ if !ok || repoURL == "" {
+ errors = append(errors, ValidationError{
+ Field: "repo_url",
+ Message: "repo_url is required",
+ })
+ } else {
+ if !GitURL.MatchString(repoURL) {
+ errors = append(errors, ValidationError{
+ Field: "repo_url",
+ Message: "invalid git repository URL format",
+ })
+ } else {
+ // Additional URL validation
+ if _, err := url.Parse(repoURL); err != nil {
+ errors = append(errors, ValidationError{
+ Field: "repo_url",
+ Message: "malformed URL",
+ })
+ }
+ }
+ }
+
+ // Validate optional description
+ if desc, exists := req["description"]; exists {
+ if descStr, ok := desc.(string); ok && len(descStr) > 1000 {
+ errors = append(errors, ValidationError{
+ Field: "description",
+ Message: "description too long (max 1000 chars)",
+ })
+ }
+ }
+
+ return errors
+}
+
+// ValidateTaskRequest validates task creation/update requests
+func ValidateTaskRequest(req map[string]interface{}) ValidationErrors {
+ var errors ValidationErrors
+
+ // Validate title
+ title, ok := req["title"].(string)
+ if !ok || title == "" {
+ errors = append(errors, ValidationError{
+ Field: "title",
+ Message: "title is required",
+ })
+ } else if !TaskTitle.MatchString(title) {
+ errors = append(errors, ValidationError{
+ Field: "title",
+ Message: "title contains invalid characters or is too long (max 200 chars)",
+ })
+ }
+
+ // Validate description
+ description, ok := req["description"].(string)
+ if !ok || description == "" {
+ errors = append(errors, ValidationError{
+ Field: "description",
+ Message: "description is required",
+ })
+ } else if len(description) > 5000 {
+ errors = append(errors, ValidationError{
+ Field: "description",
+ Message: "description too long (max 5000 chars)",
+ })
+ }
+
+ // Validate priority (if provided)
+ if priority, exists := req["priority"]; exists {
+ if priorityStr, ok := priority.(string); ok {
+ validPriorities := []string{"low", "medium", "high", "critical"}
+ isValid := false
+ for _, valid := range validPriorities {
+ if strings.ToLower(priorityStr) == valid {
+ isValid = true
+ break
+ }
+ }
+ if !isValid {
+ errors = append(errors, ValidationError{
+ Field: "priority",
+ Message: "priority must be one of: low, medium, high, critical",
+ })
+ }
+ }
+ }
+
+ return errors
+}
+
+// ValidateAgentRequest validates agent registration requests
+func ValidateAgentRequest(req map[string]interface{}) ValidationErrors {
+ var errors ValidationErrors
+
+ // Validate agent_id
+ agentID, ok := req["agent_id"].(string)
+ if !ok || agentID == "" {
+ errors = append(errors, ValidationError{
+ Field: "agent_id",
+ Message: "agent_id is required",
+ })
+ } else if !AgentID.MatchString(agentID) {
+ errors = append(errors, ValidationError{
+ Field: "agent_id",
+ Message: "agent_id contains invalid characters or is too long (max 50 chars)",
+ })
+ }
+
+ // Validate capabilities (if provided)
+ if capabilities, exists := req["capabilities"]; exists {
+ if capArray, ok := capabilities.([]interface{}); ok {
+ if len(capArray) > 50 {
+ errors = append(errors, ValidationError{
+ Field: "capabilities",
+ Message: "too many capabilities (max 50)",
+ })
+ }
+ for i, cap := range capArray {
+ if capStr, ok := cap.(string); !ok || len(capStr) > 100 {
+ errors = append(errors, ValidationError{
+ Field: fmt.Sprintf("capabilities[%d]", i),
+ Message: "capability must be string with max 100 chars",
+ })
+ }
+ }
+ }
+ }
+
+ return errors
+}
+
+// ValidatePathParameter validates URL path parameters
+func ValidatePathParameter(param, value, paramType string) error {
+ if value == "" {
+ return fmt.Errorf("%s is required", param)
+ }
+
+ switch paramType {
+ case "uuid":
+ if !UUID.MatchString(value) {
+ return fmt.Errorf("invalid %s format (must be UUID)", param)
+ }
+ case "alphanumeric":
+ if !AlphaNumeric.MatchString(value) {
+ return fmt.Errorf("invalid %s format (alphanumeric only)", param)
+ }
+ case "agent_id":
+ if !AgentID.MatchString(value) {
+ return fmt.Errorf("invalid %s format", param)
+ }
+ }
+
+ return nil
+}
+
+// SanitizeString removes potentially dangerous characters
+func SanitizeString(input string) string {
+ // Remove null bytes
+ input = strings.ReplaceAll(input, "\x00", "")
+
+ // Trim whitespace
+ input = strings.TrimSpace(input)
+
+ return input
+}
+
+// ValidateAndRespond validates data and responds with errors if validation fails
+func (v *Validator) ValidateAndRespond(w http.ResponseWriter, r *http.Request, errors ValidationErrors) bool {
+ if len(errors) > 0 {
+ log.Warn().Interface("errors", errors).Msg("Validation failed")
+ render.Status(r, http.StatusBadRequest)
+ render.JSON(w, r, map[string]interface{}{
+ "error": "validation failed",
+ "errors": errors,
+ })
+ return false
+ }
+ return true
+}
+
+// SecurityHeaders adds security headers to the response
+func SecurityHeaders(next http.Handler) http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ // Content Security Policy
+ w.Header().Set("Content-Security-Policy", "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'")
+
+ // X-Frame-Options
+ w.Header().Set("X-Frame-Options", "DENY")
+
+ // X-Content-Type-Options
+ w.Header().Set("X-Content-Type-Options", "nosniff")
+
+ // X-XSS-Protection
+ w.Header().Set("X-XSS-Protection", "1; mode=block")
+
+ // Referrer Policy
+ w.Header().Set("Referrer-Policy", "strict-origin-when-cross-origin")
+
+ next.ServeHTTP(w, r)
+ })
+}
\ No newline at end of file
diff --git a/migrations/006_add_performance_indexes.down.sql b/migrations/006_add_performance_indexes.down.sql
new file mode 100644
index 0000000..8005a7d
--- /dev/null
+++ b/migrations/006_add_performance_indexes.down.sql
@@ -0,0 +1,23 @@
+-- Drop performance optimization indexes for WHOOSH
+
+-- Drop agents table performance indexes
+DROP INDEX IF EXISTS idx_agents_status_last_seen;
+
+-- Drop repositories table performance indexes
+DROP INDEX IF EXISTS idx_repositories_full_name_lookup;
+DROP INDEX IF EXISTS idx_repositories_last_issue_sync;
+
+-- Drop tasks table performance indexes
+DROP INDEX IF EXISTS idx_tasks_external_source_lookup;
+
+-- Drop council_agents table performance indexes
+DROP INDEX IF EXISTS idx_council_agents_council_lookup;
+
+-- Drop additional performance indexes
+DROP INDEX IF EXISTS idx_teams_status_task;
+DROP INDEX IF EXISTS idx_repository_webhooks_active_repo;
+DROP INDEX IF EXISTS idx_repository_sync_logs_recent;
+DROP INDEX IF EXISTS idx_task_assignments_active;
+DROP INDEX IF EXISTS idx_council_agents_deployment_status;
+DROP INDEX IF EXISTS idx_tasks_completion_analysis;
+DROP INDEX IF EXISTS idx_agents_performance_monitoring;
\ No newline at end of file
diff --git a/migrations/006_add_performance_indexes.up.sql b/migrations/006_add_performance_indexes.up.sql
new file mode 100644
index 0000000..fd49b86
--- /dev/null
+++ b/migrations/006_add_performance_indexes.up.sql
@@ -0,0 +1,50 @@
+-- Performance optimization indexes for WHOOSH
+-- These indexes improve query performance for common access patterns
+
+-- Agents table performance indexes
+-- Composite index for status and last_seen filtering
+CREATE INDEX IF NOT EXISTS idx_agents_status_last_seen ON agents(status, last_seen);
+
+-- Repositories table performance indexes
+-- Index on full_name for repository lookups
+CREATE INDEX IF NOT EXISTS idx_repositories_full_name_lookup ON repositories(full_name);
+
+-- Index on last_issue_sync for monitoring sync operations
+CREATE INDEX IF NOT EXISTS idx_repositories_last_issue_sync ON repositories(last_issue_sync);
+
+-- Tasks table performance indexes
+-- Composite index for external_id and source_type lookups
+CREATE INDEX IF NOT EXISTS idx_tasks_external_source_lookup ON tasks(external_id, source_type);
+
+-- Councils table performance indexes
+-- Index on councils.id for faster council lookups (covering existing primary key)
+-- Note: Primary key already provides this, but adding explicit index for clarity
+-- CREATE INDEX IF NOT EXISTS idx_councils_id ON councils(id); -- Redundant with PRIMARY KEY
+
+-- Council_agents table performance indexes
+-- Index on council_id for agent-to-council lookups
+CREATE INDEX IF NOT EXISTS idx_council_agents_council_lookup ON council_agents(council_id);
+
+-- Additional performance indexes based on common query patterns
+
+-- Teams table - index on status and task relationships
+CREATE INDEX IF NOT EXISTS idx_teams_status_task ON teams(status, current_task_id);
+
+-- Repository webhooks - index for active webhook lookups
+CREATE INDEX IF NOT EXISTS idx_repository_webhooks_active_repo ON repository_webhooks(is_active, repository_id);
+
+-- Repository sync logs - index for recent sync monitoring
+CREATE INDEX IF NOT EXISTS idx_repository_sync_logs_recent ON repository_sync_logs(repository_id, created_at DESC);
+
+-- Task assignments - index for active assignments
+CREATE INDEX IF NOT EXISTS idx_task_assignments_active ON team_assignments(status, team_id, agent_id) WHERE status = 'active';
+
+-- Council agents - index for deployment status monitoring
+CREATE INDEX IF NOT EXISTS idx_council_agents_deployment_status ON council_agents(deployed, status, council_id);
+
+-- Performance statistics collection support
+-- Index for task completion analysis
+CREATE INDEX IF NOT EXISTS idx_tasks_completion_analysis ON tasks(status, completed_at, assigned_team_id) WHERE completed_at IS NOT NULL;
+
+-- Index for agent performance monitoring
+CREATE INDEX IF NOT EXISTS idx_agents_performance_monitoring ON agents(status, last_seen, updated_at) WHERE status IN ('available', 'busy', 'error');
\ No newline at end of file
diff --git a/vendor/github.com/Microsoft/go-winio/.gitattributes b/vendor/github.com/Microsoft/go-winio/.gitattributes
new file mode 100644
index 0000000..94f480d
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/.gitattributes
@@ -0,0 +1 @@
+* text=auto eol=lf
\ No newline at end of file
diff --git a/vendor/github.com/Microsoft/go-winio/.gitignore b/vendor/github.com/Microsoft/go-winio/.gitignore
new file mode 100644
index 0000000..815e206
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/.gitignore
@@ -0,0 +1,10 @@
+.vscode/
+
+*.exe
+
+# testing
+testdata
+
+# go workspaces
+go.work
+go.work.sum
diff --git a/vendor/github.com/Microsoft/go-winio/.golangci.yml b/vendor/github.com/Microsoft/go-winio/.golangci.yml
new file mode 100644
index 0000000..7b503d2
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/.golangci.yml
@@ -0,0 +1,149 @@
+run:
+ skip-dirs:
+ - pkg/etw/sample
+
+linters:
+ enable:
+ # style
+ - containedctx # struct contains a context
+ - dupl # duplicate code
+ - errname # erorrs are named correctly
+ - nolintlint # "//nolint" directives are properly explained
+ - revive # golint replacement
+ - unconvert # unnecessary conversions
+ - wastedassign
+
+ # bugs, performance, unused, etc ...
+ - contextcheck # function uses a non-inherited context
+ - errorlint # errors not wrapped for 1.13
+ - exhaustive # check exhaustiveness of enum switch statements
+ - gofmt # files are gofmt'ed
+ - gosec # security
+ - nilerr # returns nil even with non-nil error
+ - unparam # unused function params
+
+issues:
+ exclude-rules:
+ # err is very often shadowed in nested scopes
+ - linters:
+ - govet
+ text: '^shadow: declaration of "err" shadows declaration'
+
+ # ignore long lines for skip autogen directives
+ - linters:
+ - revive
+ text: "^line-length-limit: "
+ source: "^//(go:generate|sys) "
+
+ #TODO: remove after upgrading to go1.18
+ # ignore comment spacing for nolint and sys directives
+ - linters:
+ - revive
+ text: "^comment-spacings: no space between comment delimiter and comment text"
+ source: "//(cspell:|nolint:|sys |todo)"
+
+ # not on go 1.18 yet, so no any
+ - linters:
+ - revive
+ text: "^use-any: since GO 1.18 'interface{}' can be replaced by 'any'"
+
+ # allow unjustified ignores of error checks in defer statements
+ - linters:
+ - nolintlint
+ text: "^directive `//nolint:errcheck` should provide explanation"
+ source: '^\s*defer '
+
+ # allow unjustified ignores of error lints for io.EOF
+ - linters:
+ - nolintlint
+ text: "^directive `//nolint:errorlint` should provide explanation"
+ source: '[=|!]= io.EOF'
+
+
+linters-settings:
+ exhaustive:
+ default-signifies-exhaustive: true
+ govet:
+ enable-all: true
+ disable:
+ # struct order is often for Win32 compat
+ # also, ignore pointer bytes/GC issues for now until performance becomes an issue
+ - fieldalignment
+ check-shadowing: true
+ nolintlint:
+ allow-leading-space: false
+ require-explanation: true
+ require-specific: true
+ revive:
+ # revive is more configurable than static check, so likely the preferred alternative to static-check
+ # (once the perf issue is solved: https://github.com/golangci/golangci-lint/issues/2997)
+ enable-all-rules:
+ true
+ # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md
+ rules:
+ # rules with required arguments
+ - name: argument-limit
+ disabled: true
+ - name: banned-characters
+ disabled: true
+ - name: cognitive-complexity
+ disabled: true
+ - name: cyclomatic
+ disabled: true
+ - name: file-header
+ disabled: true
+ - name: function-length
+ disabled: true
+ - name: function-result-limit
+ disabled: true
+ - name: max-public-structs
+ disabled: true
+ # geneally annoying rules
+ - name: add-constant # complains about any and all strings and integers
+ disabled: true
+ - name: confusing-naming # we frequently use "Foo()" and "foo()" together
+ disabled: true
+ - name: flag-parameter # excessive, and a common idiom we use
+ disabled: true
+ - name: unhandled-error # warns over common fmt.Print* and io.Close; rely on errcheck instead
+ disabled: true
+ # general config
+ - name: line-length-limit
+ arguments:
+ - 140
+ - name: var-naming
+ arguments:
+ - []
+ - - CID
+ - CRI
+ - CTRD
+ - DACL
+ - DLL
+ - DOS
+ - ETW
+ - FSCTL
+ - GCS
+ - GMSA
+ - HCS
+ - HV
+ - IO
+ - LCOW
+ - LDAP
+ - LPAC
+ - LTSC
+ - MMIO
+ - NT
+ - OCI
+ - PMEM
+ - PWSH
+ - RX
+ - SACl
+ - SID
+ - SMB
+ - TX
+ - VHD
+ - VHDX
+ - VMID
+ - VPCI
+ - WCOW
+ - WIM
diff --git a/vendor/github.com/Microsoft/go-winio/CODEOWNERS b/vendor/github.com/Microsoft/go-winio/CODEOWNERS
new file mode 100644
index 0000000..ae1b494
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/CODEOWNERS
@@ -0,0 +1 @@
+ * @microsoft/containerplat
diff --git a/vendor/github.com/Microsoft/go-winio/LICENSE b/vendor/github.com/Microsoft/go-winio/LICENSE
new file mode 100644
index 0000000..b8b569d
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/LICENSE
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Microsoft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
diff --git a/vendor/github.com/Microsoft/go-winio/README.md b/vendor/github.com/Microsoft/go-winio/README.md
new file mode 100644
index 0000000..7474b4f
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/README.md
@@ -0,0 +1,89 @@
+# go-winio [](https://github.com/microsoft/go-winio/actions/workflows/ci.yml)
+
+This repository contains utilities for efficiently performing Win32 IO operations in
+Go. Currently, this is focused on accessing named pipes and other file handles, and
+for using named pipes as a net transport.
+
+This code relies on IO completion ports to avoid blocking IO on system threads, allowing Go
+to reuse the thread to schedule another goroutine. This limits support to Windows Vista and
+newer operating systems. This is similar to the implementation of network sockets in Go's net
+package.
+
+Please see the LICENSE file for licensing information.
+
+## Contributing
+
+This project welcomes contributions and suggestions.
+Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that
+you have the right to, and actually do, grant us the rights to use your contribution.
+For details, visit [Microsoft CLA](https://cla.microsoft.com).
+
+When you submit a pull request, a CLA-bot will automatically determine whether you need to
+provide a CLA and decorate the PR appropriately (e.g., label, comment).
+Simply follow the instructions provided by the bot.
+You will only need to do this once across all repos using our CLA.
+
+Additionally, the pull request pipeline requires the following steps to be performed before
+mergining.
+
+### Code Sign-Off
+
+We require that contributors sign their commits using [`git commit --signoff`][git-commit-s]
+to certify they either authored the work themselves or otherwise have permission to use it in this project.
+
+A range of commits can be signed off using [`git rebase --signoff`][git-rebase-s].
+
+Please see [the developer certificate](https://developercertificate.org) for more info,
+as well as to make sure that you can attest to the rules listed.
+Our CI uses the DCO Github app to ensure that all commits in a given PR are signed-off.
+
+### Linting
+
+Code must pass a linting stage, which uses [`golangci-lint`][lint].
+The linting settings are stored in [`.golangci.yaml`](./.golangci.yaml), and can be run
+automatically with VSCode by adding the following to your workspace or folder settings:
+
+```json
+ "go.lintTool": "golangci-lint",
+ "go.lintOnSave": "package",
+```
+
+Additional editor [integrations options are also available][lint-ide].
+
+Alternatively, `golangci-lint` can be [installed locally][lint-install] and run from the repo root:
+
+```shell
+# use . or specify a path to only lint a package
+# to show all lint errors, use flags "--max-issues-per-linter=0 --max-same-issues=0"
+> golangci-lint run ./...
+```
+
+### Go Generate
+
+The pipeline checks that auto-generated code, via `go generate`, are up to date.
+
+This can be done for the entire repo:
+
+```shell
+> go generate ./...
+```
+
+## Code of Conduct
+
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
+For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or
+contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
+
+## Special Thanks
+
+Thanks to [natefinch][natefinch] for the inspiration for this library.
+See [npipe](https://github.com/natefinch/npipe) for another named pipe implementation.
+
+[lint]: https://golangci-lint.run/
+[lint-ide]: https://golangci-lint.run/usage/integrations/#editor-integration
+[lint-install]: https://golangci-lint.run/usage/install/#local-installation
+
+[git-commit-s]: https://git-scm.com/docs/git-commit#Documentation/git-commit.txt--s
+[git-rebase-s]: https://git-scm.com/docs/git-rebase#Documentation/git-rebase.txt---signoff
+
+[natefinch]: https://github.com/natefinch
diff --git a/vendor/github.com/Microsoft/go-winio/SECURITY.md b/vendor/github.com/Microsoft/go-winio/SECURITY.md
new file mode 100644
index 0000000..869fdfe
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/SECURITY.md
@@ -0,0 +1,41 @@
+
+
+## Security
+
+Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [our GitHub organizations](https://opensource.microsoft.com/).
+
+If you believe you have found a security vulnerability in any Microsoft-owned repository that meets [Microsoft's definition of a security vulnerability](https://aka.ms/opensource/security/definition), please report it to us as described below.
+
+## Reporting Security Issues
+
+**Please do not report security vulnerabilities through public GitHub issues.**
+
+Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://aka.ms/opensource/security/create-report).
+
+If you prefer to submit without logging in, send email to [secure@microsoft.com](mailto:secure@microsoft.com). If possible, encrypt your message with our PGP key; please download it from the [Microsoft Security Response Center PGP Key page](https://aka.ms/opensource/security/pgpkey).
+
+You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://aka.ms/opensource/security/msrc).
+
+Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue:
+
+ * Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.)
+ * Full paths of source file(s) related to the manifestation of the issue
+ * The location of the affected source code (tag/branch/commit or direct URL)
+ * Any special configuration required to reproduce the issue
+ * Step-by-step instructions to reproduce the issue
+ * Proof-of-concept or exploit code (if possible)
+ * Impact of the issue, including how an attacker might exploit the issue
+
+This information will help us triage your report more quickly.
+
+If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://aka.ms/opensource/security/bounty) page for more details about our active programs.
+
+## Preferred Languages
+
+We prefer all communications to be in English.
+
+## Policy
+
+Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://aka.ms/opensource/security/cvd).
+
+
diff --git a/vendor/github.com/Microsoft/go-winio/backup.go b/vendor/github.com/Microsoft/go-winio/backup.go
new file mode 100644
index 0000000..09621c8
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/backup.go
@@ -0,0 +1,290 @@
+//go:build windows
+// +build windows
+
+package winio
+
+import (
+ "encoding/binary"
+ "errors"
+ "fmt"
+ "io"
+ "os"
+ "runtime"
+ "syscall"
+ "unicode/utf16"
+
+ "golang.org/x/sys/windows"
+)
+
+//sys backupRead(h syscall.Handle, b []byte, bytesRead *uint32, abort bool, processSecurity bool, context *uintptr) (err error) = BackupRead
+//sys backupWrite(h syscall.Handle, b []byte, bytesWritten *uint32, abort bool, processSecurity bool, context *uintptr) (err error) = BackupWrite
+
+const (
+ BackupData = uint32(iota + 1)
+ BackupEaData
+ BackupSecurity
+ BackupAlternateData
+ BackupLink
+ BackupPropertyData
+ BackupObjectId //revive:disable-line:var-naming ID, not Id
+ BackupReparseData
+ BackupSparseBlock
+ BackupTxfsData
+)
+
+const (
+ StreamSparseAttributes = uint32(8)
+)
+
+//nolint:revive // var-naming: ALL_CAPS
+const (
+ WRITE_DAC = windows.WRITE_DAC
+ WRITE_OWNER = windows.WRITE_OWNER
+ ACCESS_SYSTEM_SECURITY = windows.ACCESS_SYSTEM_SECURITY
+)
+
+// BackupHeader represents a backup stream of a file.
+type BackupHeader struct {
+ //revive:disable-next-line:var-naming ID, not Id
+ Id uint32 // The backup stream ID
+ Attributes uint32 // Stream attributes
+ Size int64 // The size of the stream in bytes
+ Name string // The name of the stream (for BackupAlternateData only).
+ Offset int64 // The offset of the stream in the file (for BackupSparseBlock only).
+}
+
+type win32StreamID struct {
+ StreamID uint32
+ Attributes uint32
+ Size uint64
+ NameSize uint32
+}
+
+// BackupStreamReader reads from a stream produced by the BackupRead Win32 API and produces a series
+// of BackupHeader values.
+type BackupStreamReader struct {
+ r io.Reader
+ bytesLeft int64
+}
+
+// NewBackupStreamReader produces a BackupStreamReader from any io.Reader.
+func NewBackupStreamReader(r io.Reader) *BackupStreamReader {
+ return &BackupStreamReader{r, 0}
+}
+
+// Next returns the next backup stream and prepares for calls to Read(). It skips the remainder of the current stream if
+// it was not completely read.
+func (r *BackupStreamReader) Next() (*BackupHeader, error) {
+ if r.bytesLeft > 0 { //nolint:nestif // todo: flatten this
+ if s, ok := r.r.(io.Seeker); ok {
+ // Make sure Seek on io.SeekCurrent sometimes succeeds
+ // before trying the actual seek.
+ if _, err := s.Seek(0, io.SeekCurrent); err == nil {
+ if _, err = s.Seek(r.bytesLeft, io.SeekCurrent); err != nil {
+ return nil, err
+ }
+ r.bytesLeft = 0
+ }
+ }
+ if _, err := io.Copy(io.Discard, r); err != nil {
+ return nil, err
+ }
+ }
+ var wsi win32StreamID
+ if err := binary.Read(r.r, binary.LittleEndian, &wsi); err != nil {
+ return nil, err
+ }
+ hdr := &BackupHeader{
+ Id: wsi.StreamID,
+ Attributes: wsi.Attributes,
+ Size: int64(wsi.Size),
+ }
+ if wsi.NameSize != 0 {
+ name := make([]uint16, int(wsi.NameSize/2))
+ if err := binary.Read(r.r, binary.LittleEndian, name); err != nil {
+ return nil, err
+ }
+ hdr.Name = syscall.UTF16ToString(name)
+ }
+ if wsi.StreamID == BackupSparseBlock {
+ if err := binary.Read(r.r, binary.LittleEndian, &hdr.Offset); err != nil {
+ return nil, err
+ }
+ hdr.Size -= 8
+ }
+ r.bytesLeft = hdr.Size
+ return hdr, nil
+}
+
+// Read reads from the current backup stream.
+func (r *BackupStreamReader) Read(b []byte) (int, error) {
+ if r.bytesLeft == 0 {
+ return 0, io.EOF
+ }
+ if int64(len(b)) > r.bytesLeft {
+ b = b[:r.bytesLeft]
+ }
+ n, err := r.r.Read(b)
+ r.bytesLeft -= int64(n)
+ if err == io.EOF {
+ err = io.ErrUnexpectedEOF
+ } else if r.bytesLeft == 0 && err == nil {
+ err = io.EOF
+ }
+ return n, err
+}
+
+// BackupStreamWriter writes a stream compatible with the BackupWrite Win32 API.
+type BackupStreamWriter struct {
+ w io.Writer
+ bytesLeft int64
+}
+
+// NewBackupStreamWriter produces a BackupStreamWriter on top of an io.Writer.
+func NewBackupStreamWriter(w io.Writer) *BackupStreamWriter {
+ return &BackupStreamWriter{w, 0}
+}
+
+// WriteHeader writes the next backup stream header and prepares for calls to Write().
+func (w *BackupStreamWriter) WriteHeader(hdr *BackupHeader) error {
+ if w.bytesLeft != 0 {
+ return fmt.Errorf("missing %d bytes", w.bytesLeft)
+ }
+ name := utf16.Encode([]rune(hdr.Name))
+ wsi := win32StreamID{
+ StreamID: hdr.Id,
+ Attributes: hdr.Attributes,
+ Size: uint64(hdr.Size),
+ NameSize: uint32(len(name) * 2),
+ }
+ if hdr.Id == BackupSparseBlock {
+ // Include space for the int64 block offset
+ wsi.Size += 8
+ }
+ if err := binary.Write(w.w, binary.LittleEndian, &wsi); err != nil {
+ return err
+ }
+ if len(name) != 0 {
+ if err := binary.Write(w.w, binary.LittleEndian, name); err != nil {
+ return err
+ }
+ }
+ if hdr.Id == BackupSparseBlock {
+ if err := binary.Write(w.w, binary.LittleEndian, hdr.Offset); err != nil {
+ return err
+ }
+ }
+ w.bytesLeft = hdr.Size
+ return nil
+}
+
+// Write writes to the current backup stream.
+func (w *BackupStreamWriter) Write(b []byte) (int, error) {
+ if w.bytesLeft < int64(len(b)) {
+ return 0, fmt.Errorf("too many bytes by %d", int64(len(b))-w.bytesLeft)
+ }
+ n, err := w.w.Write(b)
+ w.bytesLeft -= int64(n)
+ return n, err
+}
+
+// BackupFileReader provides an io.ReadCloser interface on top of the BackupRead Win32 API.
+type BackupFileReader struct {
+ f *os.File
+ includeSecurity bool
+ ctx uintptr
+}
+
+// NewBackupFileReader returns a new BackupFileReader from a file handle. If includeSecurity is true,
+// Read will attempt to read the security descriptor of the file.
+func NewBackupFileReader(f *os.File, includeSecurity bool) *BackupFileReader {
+ r := &BackupFileReader{f, includeSecurity, 0}
+ return r
+}
+
+// Read reads a backup stream from the file by calling the Win32 API BackupRead().
+func (r *BackupFileReader) Read(b []byte) (int, error) {
+ var bytesRead uint32
+ err := backupRead(syscall.Handle(r.f.Fd()), b, &bytesRead, false, r.includeSecurity, &r.ctx)
+ if err != nil {
+ return 0, &os.PathError{Op: "BackupRead", Path: r.f.Name(), Err: err}
+ }
+ runtime.KeepAlive(r.f)
+ if bytesRead == 0 {
+ return 0, io.EOF
+ }
+ return int(bytesRead), nil
+}
+
+// Close frees Win32 resources associated with the BackupFileReader. It does not close
+// the underlying file.
+func (r *BackupFileReader) Close() error {
+ if r.ctx != 0 {
+ _ = backupRead(syscall.Handle(r.f.Fd()), nil, nil, true, false, &r.ctx)
+ runtime.KeepAlive(r.f)
+ r.ctx = 0
+ }
+ return nil
+}
+
+// BackupFileWriter provides an io.WriteCloser interface on top of the BackupWrite Win32 API.
+type BackupFileWriter struct {
+ f *os.File
+ includeSecurity bool
+ ctx uintptr
+}
+
+// NewBackupFileWriter returns a new BackupFileWriter from a file handle. If includeSecurity is true,
+// Write() will attempt to restore the security descriptor from the stream.
+func NewBackupFileWriter(f *os.File, includeSecurity bool) *BackupFileWriter {
+ w := &BackupFileWriter{f, includeSecurity, 0}
+ return w
+}
+
+// Write restores a portion of the file using the provided backup stream.
+func (w *BackupFileWriter) Write(b []byte) (int, error) {
+ var bytesWritten uint32
+ err := backupWrite(syscall.Handle(w.f.Fd()), b, &bytesWritten, false, w.includeSecurity, &w.ctx)
+ if err != nil {
+ return 0, &os.PathError{Op: "BackupWrite", Path: w.f.Name(), Err: err}
+ }
+ runtime.KeepAlive(w.f)
+ if int(bytesWritten) != len(b) {
+ return int(bytesWritten), errors.New("not all bytes could be written")
+ }
+ return len(b), nil
+}
+
+// Close frees Win32 resources associated with the BackupFileWriter. It does not
+// close the underlying file.
+func (w *BackupFileWriter) Close() error {
+ if w.ctx != 0 {
+ _ = backupWrite(syscall.Handle(w.f.Fd()), nil, nil, true, false, &w.ctx)
+ runtime.KeepAlive(w.f)
+ w.ctx = 0
+ }
+ return nil
+}
+
+// OpenForBackup opens a file or directory, potentially skipping access checks if the backup
+// or restore privileges have been acquired.
+//
+// If the file opened was a directory, it cannot be used with Readdir().
+func OpenForBackup(path string, access uint32, share uint32, createmode uint32) (*os.File, error) {
+ winPath, err := syscall.UTF16FromString(path)
+ if err != nil {
+ return nil, err
+ }
+ h, err := syscall.CreateFile(&winPath[0],
+ access,
+ share,
+ nil,
+ createmode,
+ syscall.FILE_FLAG_BACKUP_SEMANTICS|syscall.FILE_FLAG_OPEN_REPARSE_POINT,
+ 0)
+ if err != nil {
+ err = &os.PathError{Op: "open", Path: path, Err: err}
+ return nil, err
+ }
+ return os.NewFile(uintptr(h), path), nil
+}
diff --git a/vendor/github.com/Microsoft/go-winio/doc.go b/vendor/github.com/Microsoft/go-winio/doc.go
new file mode 100644
index 0000000..1f5bfe2
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/doc.go
@@ -0,0 +1,22 @@
+// This package provides utilities for efficiently performing Win32 IO operations in Go.
+// Currently, this package is provides support for genreal IO and management of
+// - named pipes
+// - files
+// - [Hyper-V sockets]
+//
+// This code is similar to Go's [net] package, and uses IO completion ports to avoid
+// blocking IO on system threads, allowing Go to reuse the thread to schedule other goroutines.
+//
+// This limits support to Windows Vista and newer operating systems.
+//
+// Additionally, this package provides support for:
+// - creating and managing GUIDs
+// - writing to [ETW]
+// - opening and manageing VHDs
+// - parsing [Windows Image files]
+// - auto-generating Win32 API code
+//
+// [Hyper-V sockets]: https://docs.microsoft.com/en-us/virtualization/hyper-v-on-windows/user-guide/make-integration-service
+// [ETW]: https://docs.microsoft.com/en-us/windows-hardware/drivers/devtest/event-tracing-for-windows--etw-
+// [Windows Image files]: https://docs.microsoft.com/en-us/windows-hardware/manufacture/desktop/work-with-windows-images
+package winio
diff --git a/vendor/github.com/Microsoft/go-winio/ea.go b/vendor/github.com/Microsoft/go-winio/ea.go
new file mode 100644
index 0000000..e104dbd
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/ea.go
@@ -0,0 +1,137 @@
+package winio
+
+import (
+ "bytes"
+ "encoding/binary"
+ "errors"
+)
+
+type fileFullEaInformation struct {
+ NextEntryOffset uint32
+ Flags uint8
+ NameLength uint8
+ ValueLength uint16
+}
+
+var (
+ fileFullEaInformationSize = binary.Size(&fileFullEaInformation{})
+
+ errInvalidEaBuffer = errors.New("invalid extended attribute buffer")
+ errEaNameTooLarge = errors.New("extended attribute name too large")
+ errEaValueTooLarge = errors.New("extended attribute value too large")
+)
+
+// ExtendedAttribute represents a single Windows EA.
+type ExtendedAttribute struct {
+ Name string
+ Value []byte
+ Flags uint8
+}
+
+func parseEa(b []byte) (ea ExtendedAttribute, nb []byte, err error) {
+ var info fileFullEaInformation
+ err = binary.Read(bytes.NewReader(b), binary.LittleEndian, &info)
+ if err != nil {
+ err = errInvalidEaBuffer
+ return ea, nb, err
+ }
+
+ nameOffset := fileFullEaInformationSize
+ nameLen := int(info.NameLength)
+ valueOffset := nameOffset + int(info.NameLength) + 1
+ valueLen := int(info.ValueLength)
+ nextOffset := int(info.NextEntryOffset)
+ if valueLen+valueOffset > len(b) || nextOffset < 0 || nextOffset > len(b) {
+ err = errInvalidEaBuffer
+ return ea, nb, err
+ }
+
+ ea.Name = string(b[nameOffset : nameOffset+nameLen])
+ ea.Value = b[valueOffset : valueOffset+valueLen]
+ ea.Flags = info.Flags
+ if info.NextEntryOffset != 0 {
+ nb = b[info.NextEntryOffset:]
+ }
+ return ea, nb, err
+}
+
+// DecodeExtendedAttributes decodes a list of EAs from a FILE_FULL_EA_INFORMATION
+// buffer retrieved from BackupRead, ZwQueryEaFile, etc.
+func DecodeExtendedAttributes(b []byte) (eas []ExtendedAttribute, err error) {
+ for len(b) != 0 {
+ ea, nb, err := parseEa(b)
+ if err != nil {
+ return nil, err
+ }
+
+ eas = append(eas, ea)
+ b = nb
+ }
+ return eas, err
+}
+
+func writeEa(buf *bytes.Buffer, ea *ExtendedAttribute, last bool) error {
+ if int(uint8(len(ea.Name))) != len(ea.Name) {
+ return errEaNameTooLarge
+ }
+ if int(uint16(len(ea.Value))) != len(ea.Value) {
+ return errEaValueTooLarge
+ }
+ entrySize := uint32(fileFullEaInformationSize + len(ea.Name) + 1 + len(ea.Value))
+ withPadding := (entrySize + 3) &^ 3
+ nextOffset := uint32(0)
+ if !last {
+ nextOffset = withPadding
+ }
+ info := fileFullEaInformation{
+ NextEntryOffset: nextOffset,
+ Flags: ea.Flags,
+ NameLength: uint8(len(ea.Name)),
+ ValueLength: uint16(len(ea.Value)),
+ }
+
+ err := binary.Write(buf, binary.LittleEndian, &info)
+ if err != nil {
+ return err
+ }
+
+ _, err = buf.Write([]byte(ea.Name))
+ if err != nil {
+ return err
+ }
+
+ err = buf.WriteByte(0)
+ if err != nil {
+ return err
+ }
+
+ _, err = buf.Write(ea.Value)
+ if err != nil {
+ return err
+ }
+
+ _, err = buf.Write([]byte{0, 0, 0}[0 : withPadding-entrySize])
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
+
+// EncodeExtendedAttributes encodes a list of EAs into a FILE_FULL_EA_INFORMATION
+// buffer for use with BackupWrite, ZwSetEaFile, etc.
+func EncodeExtendedAttributes(eas []ExtendedAttribute) ([]byte, error) {
+ var buf bytes.Buffer
+ for i := range eas {
+ last := false
+ if i == len(eas)-1 {
+ last = true
+ }
+
+ err := writeEa(&buf, &eas[i], last)
+ if err != nil {
+ return nil, err
+ }
+ }
+ return buf.Bytes(), nil
+}
diff --git a/vendor/github.com/Microsoft/go-winio/file.go b/vendor/github.com/Microsoft/go-winio/file.go
new file mode 100644
index 0000000..175a99d
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/file.go
@@ -0,0 +1,331 @@
+//go:build windows
+// +build windows
+
+package winio
+
+import (
+ "errors"
+ "io"
+ "runtime"
+ "sync"
+ "sync/atomic"
+ "syscall"
+ "time"
+
+ "golang.org/x/sys/windows"
+)
+
+//sys cancelIoEx(file syscall.Handle, o *syscall.Overlapped) (err error) = CancelIoEx
+//sys createIoCompletionPort(file syscall.Handle, port syscall.Handle, key uintptr, threadCount uint32) (newport syscall.Handle, err error) = CreateIoCompletionPort
+//sys getQueuedCompletionStatus(port syscall.Handle, bytes *uint32, key *uintptr, o **ioOperation, timeout uint32) (err error) = GetQueuedCompletionStatus
+//sys setFileCompletionNotificationModes(h syscall.Handle, flags uint8) (err error) = SetFileCompletionNotificationModes
+//sys wsaGetOverlappedResult(h syscall.Handle, o *syscall.Overlapped, bytes *uint32, wait bool, flags *uint32) (err error) = ws2_32.WSAGetOverlappedResult
+
+type atomicBool int32
+
+func (b *atomicBool) isSet() bool { return atomic.LoadInt32((*int32)(b)) != 0 }
+func (b *atomicBool) setFalse() { atomic.StoreInt32((*int32)(b), 0) }
+func (b *atomicBool) setTrue() { atomic.StoreInt32((*int32)(b), 1) }
+
+//revive:disable-next-line:predeclared Keep "new" to maintain consistency with "atomic" pkg
+func (b *atomicBool) swap(new bool) bool {
+ var newInt int32
+ if new {
+ newInt = 1
+ }
+ return atomic.SwapInt32((*int32)(b), newInt) == 1
+}
+
+var (
+ ErrFileClosed = errors.New("file has already been closed")
+ ErrTimeout = &timeoutError{}
+)
+
+type timeoutError struct{}
+
+func (*timeoutError) Error() string { return "i/o timeout" }
+func (*timeoutError) Timeout() bool { return true }
+func (*timeoutError) Temporary() bool { return true }
+
+type timeoutChan chan struct{}
+
+var ioInitOnce sync.Once
+var ioCompletionPort syscall.Handle
+
+// ioResult contains the result of an asynchronous IO operation.
+type ioResult struct {
+ bytes uint32
+ err error
+}
+
+// ioOperation represents an outstanding asynchronous Win32 IO.
+type ioOperation struct {
+ o syscall.Overlapped
+ ch chan ioResult
+}
+
+func initIO() {
+ h, err := createIoCompletionPort(syscall.InvalidHandle, 0, 0, 0xffffffff)
+ if err != nil {
+ panic(err)
+ }
+ ioCompletionPort = h
+ go ioCompletionProcessor(h)
+}
+
+// win32File implements Reader, Writer, and Closer on a Win32 handle without blocking in a syscall.
+// It takes ownership of this handle and will close it if it is garbage collected.
+type win32File struct {
+ handle syscall.Handle
+ wg sync.WaitGroup
+ wgLock sync.RWMutex
+ closing atomicBool
+ socket bool
+ readDeadline deadlineHandler
+ writeDeadline deadlineHandler
+}
+
+type deadlineHandler struct {
+ setLock sync.Mutex
+ channel timeoutChan
+ channelLock sync.RWMutex
+ timer *time.Timer
+ timedout atomicBool
+}
+
+// makeWin32File makes a new win32File from an existing file handle.
+func makeWin32File(h syscall.Handle) (*win32File, error) {
+ f := &win32File{handle: h}
+ ioInitOnce.Do(initIO)
+ _, err := createIoCompletionPort(h, ioCompletionPort, 0, 0xffffffff)
+ if err != nil {
+ return nil, err
+ }
+ err = setFileCompletionNotificationModes(h, windows.FILE_SKIP_COMPLETION_PORT_ON_SUCCESS|windows.FILE_SKIP_SET_EVENT_ON_HANDLE)
+ if err != nil {
+ return nil, err
+ }
+ f.readDeadline.channel = make(timeoutChan)
+ f.writeDeadline.channel = make(timeoutChan)
+ return f, nil
+}
+
+func MakeOpenFile(h syscall.Handle) (io.ReadWriteCloser, error) {
+ // If we return the result of makeWin32File directly, it can result in an
+ // interface-wrapped nil, rather than a nil interface value.
+ f, err := makeWin32File(h)
+ if err != nil {
+ return nil, err
+ }
+ return f, nil
+}
+
+// closeHandle closes the resources associated with a Win32 handle.
+func (f *win32File) closeHandle() {
+ f.wgLock.Lock()
+ // Atomically set that we are closing, releasing the resources only once.
+ if !f.closing.swap(true) {
+ f.wgLock.Unlock()
+ // cancel all IO and wait for it to complete
+ _ = cancelIoEx(f.handle, nil)
+ f.wg.Wait()
+ // at this point, no new IO can start
+ syscall.Close(f.handle)
+ f.handle = 0
+ } else {
+ f.wgLock.Unlock()
+ }
+}
+
+// Close closes a win32File.
+func (f *win32File) Close() error {
+ f.closeHandle()
+ return nil
+}
+
+// IsClosed checks if the file has been closed.
+func (f *win32File) IsClosed() bool {
+ return f.closing.isSet()
+}
+
+// prepareIO prepares for a new IO operation.
+// The caller must call f.wg.Done() when the IO is finished, prior to Close() returning.
+func (f *win32File) prepareIO() (*ioOperation, error) {
+ f.wgLock.RLock()
+ if f.closing.isSet() {
+ f.wgLock.RUnlock()
+ return nil, ErrFileClosed
+ }
+ f.wg.Add(1)
+ f.wgLock.RUnlock()
+ c := &ioOperation{}
+ c.ch = make(chan ioResult)
+ return c, nil
+}
+
+// ioCompletionProcessor processes completed async IOs forever.
+func ioCompletionProcessor(h syscall.Handle) {
+ for {
+ var bytes uint32
+ var key uintptr
+ var op *ioOperation
+ err := getQueuedCompletionStatus(h, &bytes, &key, &op, syscall.INFINITE)
+ if op == nil {
+ panic(err)
+ }
+ op.ch <- ioResult{bytes, err}
+ }
+}
+
+// todo: helsaawy - create an asyncIO version that takes a context
+
+// asyncIO processes the return value from ReadFile or WriteFile, blocking until
+// the operation has actually completed.
+func (f *win32File) asyncIO(c *ioOperation, d *deadlineHandler, bytes uint32, err error) (int, error) {
+ if err != syscall.ERROR_IO_PENDING { //nolint:errorlint // err is Errno
+ return int(bytes), err
+ }
+
+ if f.closing.isSet() {
+ _ = cancelIoEx(f.handle, &c.o)
+ }
+
+ var timeout timeoutChan
+ if d != nil {
+ d.channelLock.Lock()
+ timeout = d.channel
+ d.channelLock.Unlock()
+ }
+
+ var r ioResult
+ select {
+ case r = <-c.ch:
+ err = r.err
+ if err == syscall.ERROR_OPERATION_ABORTED { //nolint:errorlint // err is Errno
+ if f.closing.isSet() {
+ err = ErrFileClosed
+ }
+ } else if err != nil && f.socket {
+ // err is from Win32. Query the overlapped structure to get the winsock error.
+ var bytes, flags uint32
+ err = wsaGetOverlappedResult(f.handle, &c.o, &bytes, false, &flags)
+ }
+ case <-timeout:
+ _ = cancelIoEx(f.handle, &c.o)
+ r = <-c.ch
+ err = r.err
+ if err == syscall.ERROR_OPERATION_ABORTED { //nolint:errorlint // err is Errno
+ err = ErrTimeout
+ }
+ }
+
+ // runtime.KeepAlive is needed, as c is passed via native
+ // code to ioCompletionProcessor, c must remain alive
+ // until the channel read is complete.
+ // todo: (de)allocate *ioOperation via win32 heap functions, instead of needing to KeepAlive?
+ runtime.KeepAlive(c)
+ return int(r.bytes), err
+}
+
+// Read reads from a file handle.
+func (f *win32File) Read(b []byte) (int, error) {
+ c, err := f.prepareIO()
+ if err != nil {
+ return 0, err
+ }
+ defer f.wg.Done()
+
+ if f.readDeadline.timedout.isSet() {
+ return 0, ErrTimeout
+ }
+
+ var bytes uint32
+ err = syscall.ReadFile(f.handle, b, &bytes, &c.o)
+ n, err := f.asyncIO(c, &f.readDeadline, bytes, err)
+ runtime.KeepAlive(b)
+
+ // Handle EOF conditions.
+ if err == nil && n == 0 && len(b) != 0 {
+ return 0, io.EOF
+ } else if err == syscall.ERROR_BROKEN_PIPE { //nolint:errorlint // err is Errno
+ return 0, io.EOF
+ } else {
+ return n, err
+ }
+}
+
+// Write writes to a file handle.
+func (f *win32File) Write(b []byte) (int, error) {
+ c, err := f.prepareIO()
+ if err != nil {
+ return 0, err
+ }
+ defer f.wg.Done()
+
+ if f.writeDeadline.timedout.isSet() {
+ return 0, ErrTimeout
+ }
+
+ var bytes uint32
+ err = syscall.WriteFile(f.handle, b, &bytes, &c.o)
+ n, err := f.asyncIO(c, &f.writeDeadline, bytes, err)
+ runtime.KeepAlive(b)
+ return n, err
+}
+
+func (f *win32File) SetReadDeadline(deadline time.Time) error {
+ return f.readDeadline.set(deadline)
+}
+
+func (f *win32File) SetWriteDeadline(deadline time.Time) error {
+ return f.writeDeadline.set(deadline)
+}
+
+func (f *win32File) Flush() error {
+ return syscall.FlushFileBuffers(f.handle)
+}
+
+func (f *win32File) Fd() uintptr {
+ return uintptr(f.handle)
+}
+
+func (d *deadlineHandler) set(deadline time.Time) error {
+ d.setLock.Lock()
+ defer d.setLock.Unlock()
+
+ if d.timer != nil {
+ if !d.timer.Stop() {
+ <-d.channel
+ }
+ d.timer = nil
+ }
+ d.timedout.setFalse()
+
+ select {
+ case <-d.channel:
+ d.channelLock.Lock()
+ d.channel = make(chan struct{})
+ d.channelLock.Unlock()
+ default:
+ }
+
+ if deadline.IsZero() {
+ return nil
+ }
+
+ timeoutIO := func() {
+ d.timedout.setTrue()
+ close(d.channel)
+ }
+
+ now := time.Now()
+ duration := deadline.Sub(now)
+ if deadline.After(now) {
+ // Deadline is in the future, set a timer to wait
+ d.timer = time.AfterFunc(duration, timeoutIO)
+ } else {
+ // Deadline is in the past. Cancel all pending IO now.
+ timeoutIO()
+ }
+ return nil
+}
diff --git a/vendor/github.com/Microsoft/go-winio/fileinfo.go b/vendor/github.com/Microsoft/go-winio/fileinfo.go
new file mode 100644
index 0000000..702950e
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/fileinfo.go
@@ -0,0 +1,92 @@
+//go:build windows
+// +build windows
+
+package winio
+
+import (
+ "os"
+ "runtime"
+ "unsafe"
+
+ "golang.org/x/sys/windows"
+)
+
+// FileBasicInfo contains file access time and file attributes information.
+type FileBasicInfo struct {
+ CreationTime, LastAccessTime, LastWriteTime, ChangeTime windows.Filetime
+ FileAttributes uint32
+ _ uint32 // padding
+}
+
+// GetFileBasicInfo retrieves times and attributes for a file.
+func GetFileBasicInfo(f *os.File) (*FileBasicInfo, error) {
+ bi := &FileBasicInfo{}
+ if err := windows.GetFileInformationByHandleEx(
+ windows.Handle(f.Fd()),
+ windows.FileBasicInfo,
+ (*byte)(unsafe.Pointer(bi)),
+ uint32(unsafe.Sizeof(*bi)),
+ ); err != nil {
+ return nil, &os.PathError{Op: "GetFileInformationByHandleEx", Path: f.Name(), Err: err}
+ }
+ runtime.KeepAlive(f)
+ return bi, nil
+}
+
+// SetFileBasicInfo sets times and attributes for a file.
+func SetFileBasicInfo(f *os.File, bi *FileBasicInfo) error {
+ if err := windows.SetFileInformationByHandle(
+ windows.Handle(f.Fd()),
+ windows.FileBasicInfo,
+ (*byte)(unsafe.Pointer(bi)),
+ uint32(unsafe.Sizeof(*bi)),
+ ); err != nil {
+ return &os.PathError{Op: "SetFileInformationByHandle", Path: f.Name(), Err: err}
+ }
+ runtime.KeepAlive(f)
+ return nil
+}
+
+// FileStandardInfo contains extended information for the file.
+// FILE_STANDARD_INFO in WinBase.h
+// https://docs.microsoft.com/en-us/windows/win32/api/winbase/ns-winbase-file_standard_info
+type FileStandardInfo struct {
+ AllocationSize, EndOfFile int64
+ NumberOfLinks uint32
+ DeletePending, Directory bool
+}
+
+// GetFileStandardInfo retrieves ended information for the file.
+func GetFileStandardInfo(f *os.File) (*FileStandardInfo, error) {
+ si := &FileStandardInfo{}
+ if err := windows.GetFileInformationByHandleEx(windows.Handle(f.Fd()),
+ windows.FileStandardInfo,
+ (*byte)(unsafe.Pointer(si)),
+ uint32(unsafe.Sizeof(*si))); err != nil {
+ return nil, &os.PathError{Op: "GetFileInformationByHandleEx", Path: f.Name(), Err: err}
+ }
+ runtime.KeepAlive(f)
+ return si, nil
+}
+
+// FileIDInfo contains the volume serial number and file ID for a file. This pair should be
+// unique on a system.
+type FileIDInfo struct {
+ VolumeSerialNumber uint64
+ FileID [16]byte
+}
+
+// GetFileID retrieves the unique (volume, file ID) pair for a file.
+func GetFileID(f *os.File) (*FileIDInfo, error) {
+ fileID := &FileIDInfo{}
+ if err := windows.GetFileInformationByHandleEx(
+ windows.Handle(f.Fd()),
+ windows.FileIdInfo,
+ (*byte)(unsafe.Pointer(fileID)),
+ uint32(unsafe.Sizeof(*fileID)),
+ ); err != nil {
+ return nil, &os.PathError{Op: "GetFileInformationByHandleEx", Path: f.Name(), Err: err}
+ }
+ runtime.KeepAlive(f)
+ return fileID, nil
+}
diff --git a/vendor/github.com/Microsoft/go-winio/hvsock.go b/vendor/github.com/Microsoft/go-winio/hvsock.go
new file mode 100644
index 0000000..c881916
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/hvsock.go
@@ -0,0 +1,575 @@
+//go:build windows
+// +build windows
+
+package winio
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "io"
+ "net"
+ "os"
+ "syscall"
+ "time"
+ "unsafe"
+
+ "golang.org/x/sys/windows"
+
+ "github.com/Microsoft/go-winio/internal/socket"
+ "github.com/Microsoft/go-winio/pkg/guid"
+)
+
+const afHVSock = 34 // AF_HYPERV
+
+// Well known Service and VM IDs
+// https://docs.microsoft.com/en-us/virtualization/hyper-v-on-windows/user-guide/make-integration-service#vmid-wildcards
+
+// HvsockGUIDWildcard is the wildcard VmId for accepting connections from all partitions.
+func HvsockGUIDWildcard() guid.GUID { // 00000000-0000-0000-0000-000000000000
+ return guid.GUID{}
+}
+
+// HvsockGUIDBroadcast is the wildcard VmId for broadcasting sends to all partitions.
+func HvsockGUIDBroadcast() guid.GUID { // ffffffff-ffff-ffff-ffff-ffffffffffff
+ return guid.GUID{
+ Data1: 0xffffffff,
+ Data2: 0xffff,
+ Data3: 0xffff,
+ Data4: [8]uint8{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
+ }
+}
+
+// HvsockGUIDLoopback is the Loopback VmId for accepting connections to the same partition as the connector.
+func HvsockGUIDLoopback() guid.GUID { // e0e16197-dd56-4a10-9195-5ee7a155a838
+ return guid.GUID{
+ Data1: 0xe0e16197,
+ Data2: 0xdd56,
+ Data3: 0x4a10,
+ Data4: [8]uint8{0x91, 0x95, 0x5e, 0xe7, 0xa1, 0x55, 0xa8, 0x38},
+ }
+}
+
+// HvsockGUIDSiloHost is the address of a silo's host partition:
+// - The silo host of a hosted silo is the utility VM.
+// - The silo host of a silo on a physical host is the physical host.
+func HvsockGUIDSiloHost() guid.GUID { // 36bd0c5c-7276-4223-88ba-7d03b654c568
+ return guid.GUID{
+ Data1: 0x36bd0c5c,
+ Data2: 0x7276,
+ Data3: 0x4223,
+ Data4: [8]byte{0x88, 0xba, 0x7d, 0x03, 0xb6, 0x54, 0xc5, 0x68},
+ }
+}
+
+// HvsockGUIDChildren is the wildcard VmId for accepting connections from the connector's child partitions.
+func HvsockGUIDChildren() guid.GUID { // 90db8b89-0d35-4f79-8ce9-49ea0ac8b7cd
+ return guid.GUID{
+ Data1: 0x90db8b89,
+ Data2: 0xd35,
+ Data3: 0x4f79,
+ Data4: [8]uint8{0x8c, 0xe9, 0x49, 0xea, 0xa, 0xc8, 0xb7, 0xcd},
+ }
+}
+
+// HvsockGUIDParent is the wildcard VmId for accepting connections from the connector's parent partition.
+// Listening on this VmId accepts connection from:
+// - Inside silos: silo host partition.
+// - Inside hosted silo: host of the VM.
+// - Inside VM: VM host.
+// - Physical host: Not supported.
+func HvsockGUIDParent() guid.GUID { // a42e7cda-d03f-480c-9cc2-a4de20abb878
+ return guid.GUID{
+ Data1: 0xa42e7cda,
+ Data2: 0xd03f,
+ Data3: 0x480c,
+ Data4: [8]uint8{0x9c, 0xc2, 0xa4, 0xde, 0x20, 0xab, 0xb8, 0x78},
+ }
+}
+
+// hvsockVsockServiceTemplate is the Service GUID used for the VSOCK protocol.
+func hvsockVsockServiceTemplate() guid.GUID { // 00000000-facb-11e6-bd58-64006a7986d3
+ return guid.GUID{
+ Data2: 0xfacb,
+ Data3: 0x11e6,
+ Data4: [8]uint8{0xbd, 0x58, 0x64, 0x00, 0x6a, 0x79, 0x86, 0xd3},
+ }
+}
+
+// An HvsockAddr is an address for a AF_HYPERV socket.
+type HvsockAddr struct {
+ VMID guid.GUID
+ ServiceID guid.GUID
+}
+
+type rawHvsockAddr struct {
+ Family uint16
+ _ uint16
+ VMID guid.GUID
+ ServiceID guid.GUID
+}
+
+var _ socket.RawSockaddr = &rawHvsockAddr{}
+
+// Network returns the address's network name, "hvsock".
+func (*HvsockAddr) Network() string {
+ return "hvsock"
+}
+
+func (addr *HvsockAddr) String() string {
+ return fmt.Sprintf("%s:%s", &addr.VMID, &addr.ServiceID)
+}
+
+// VsockServiceID returns an hvsock service ID corresponding to the specified AF_VSOCK port.
+func VsockServiceID(port uint32) guid.GUID {
+ g := hvsockVsockServiceTemplate() // make a copy
+ g.Data1 = port
+ return g
+}
+
+func (addr *HvsockAddr) raw() rawHvsockAddr {
+ return rawHvsockAddr{
+ Family: afHVSock,
+ VMID: addr.VMID,
+ ServiceID: addr.ServiceID,
+ }
+}
+
+func (addr *HvsockAddr) fromRaw(raw *rawHvsockAddr) {
+ addr.VMID = raw.VMID
+ addr.ServiceID = raw.ServiceID
+}
+
+// Sockaddr returns a pointer to and the size of this struct.
+//
+// Implements the [socket.RawSockaddr] interface, and allows use in
+// [socket.Bind] and [socket.ConnectEx].
+func (r *rawHvsockAddr) Sockaddr() (unsafe.Pointer, int32, error) {
+ return unsafe.Pointer(r), int32(unsafe.Sizeof(rawHvsockAddr{})), nil
+}
+
+// Sockaddr interface allows use with `sockets.Bind()` and `.ConnectEx()`.
+func (r *rawHvsockAddr) FromBytes(b []byte) error {
+ n := int(unsafe.Sizeof(rawHvsockAddr{}))
+
+ if len(b) < n {
+ return fmt.Errorf("got %d, want %d: %w", len(b), n, socket.ErrBufferSize)
+ }
+
+ copy(unsafe.Slice((*byte)(unsafe.Pointer(r)), n), b[:n])
+ if r.Family != afHVSock {
+ return fmt.Errorf("got %d, want %d: %w", r.Family, afHVSock, socket.ErrAddrFamily)
+ }
+
+ return nil
+}
+
+// HvsockListener is a socket listener for the AF_HYPERV address family.
+type HvsockListener struct {
+ sock *win32File
+ addr HvsockAddr
+}
+
+var _ net.Listener = &HvsockListener{}
+
+// HvsockConn is a connected socket of the AF_HYPERV address family.
+type HvsockConn struct {
+ sock *win32File
+ local, remote HvsockAddr
+}
+
+var _ net.Conn = &HvsockConn{}
+
+func newHVSocket() (*win32File, error) {
+ fd, err := syscall.Socket(afHVSock, syscall.SOCK_STREAM, 1)
+ if err != nil {
+ return nil, os.NewSyscallError("socket", err)
+ }
+ f, err := makeWin32File(fd)
+ if err != nil {
+ syscall.Close(fd)
+ return nil, err
+ }
+ f.socket = true
+ return f, nil
+}
+
+// ListenHvsock listens for connections on the specified hvsock address.
+func ListenHvsock(addr *HvsockAddr) (_ *HvsockListener, err error) {
+ l := &HvsockListener{addr: *addr}
+ sock, err := newHVSocket()
+ if err != nil {
+ return nil, l.opErr("listen", err)
+ }
+ sa := addr.raw()
+ err = socket.Bind(windows.Handle(sock.handle), &sa)
+ if err != nil {
+ return nil, l.opErr("listen", os.NewSyscallError("socket", err))
+ }
+ err = syscall.Listen(sock.handle, 16)
+ if err != nil {
+ return nil, l.opErr("listen", os.NewSyscallError("listen", err))
+ }
+ return &HvsockListener{sock: sock, addr: *addr}, nil
+}
+
+func (l *HvsockListener) opErr(op string, err error) error {
+ return &net.OpError{Op: op, Net: "hvsock", Addr: &l.addr, Err: err}
+}
+
+// Addr returns the listener's network address.
+func (l *HvsockListener) Addr() net.Addr {
+ return &l.addr
+}
+
+// Accept waits for the next connection and returns it.
+func (l *HvsockListener) Accept() (_ net.Conn, err error) {
+ sock, err := newHVSocket()
+ if err != nil {
+ return nil, l.opErr("accept", err)
+ }
+ defer func() {
+ if sock != nil {
+ sock.Close()
+ }
+ }()
+ c, err := l.sock.prepareIO()
+ if err != nil {
+ return nil, l.opErr("accept", err)
+ }
+ defer l.sock.wg.Done()
+
+ // AcceptEx, per documentation, requires an extra 16 bytes per address.
+ //
+ // https://docs.microsoft.com/en-us/windows/win32/api/mswsock/nf-mswsock-acceptex
+ const addrlen = uint32(16 + unsafe.Sizeof(rawHvsockAddr{}))
+ var addrbuf [addrlen * 2]byte
+
+ var bytes uint32
+ err = syscall.AcceptEx(l.sock.handle, sock.handle, &addrbuf[0], 0 /* rxdatalen */, addrlen, addrlen, &bytes, &c.o)
+ if _, err = l.sock.asyncIO(c, nil, bytes, err); err != nil {
+ return nil, l.opErr("accept", os.NewSyscallError("acceptex", err))
+ }
+
+ conn := &HvsockConn{
+ sock: sock,
+ }
+ // The local address returned in the AcceptEx buffer is the same as the Listener socket's
+ // address. However, the service GUID reported by GetSockName is different from the Listeners
+ // socket, and is sometimes the same as the local address of the socket that dialed the
+ // address, with the service GUID.Data1 incremented, but othertimes is different.
+ // todo: does the local address matter? is the listener's address or the actual address appropriate?
+ conn.local.fromRaw((*rawHvsockAddr)(unsafe.Pointer(&addrbuf[0])))
+ conn.remote.fromRaw((*rawHvsockAddr)(unsafe.Pointer(&addrbuf[addrlen])))
+
+ // initialize the accepted socket and update its properties with those of the listening socket
+ if err = windows.Setsockopt(windows.Handle(sock.handle),
+ windows.SOL_SOCKET, windows.SO_UPDATE_ACCEPT_CONTEXT,
+ (*byte)(unsafe.Pointer(&l.sock.handle)), int32(unsafe.Sizeof(l.sock.handle))); err != nil {
+ return nil, conn.opErr("accept", os.NewSyscallError("setsockopt", err))
+ }
+
+ sock = nil
+ return conn, nil
+}
+
+// Close closes the listener, causing any pending Accept calls to fail.
+func (l *HvsockListener) Close() error {
+ return l.sock.Close()
+}
+
+// HvsockDialer configures and dials a Hyper-V Socket (ie, [HvsockConn]).
+type HvsockDialer struct {
+ // Deadline is the time the Dial operation must connect before erroring.
+ Deadline time.Time
+
+ // Retries is the number of additional connects to try if the connection times out, is refused,
+ // or the host is unreachable
+ Retries uint
+
+ // RetryWait is the time to wait after a connection error to retry
+ RetryWait time.Duration
+
+ rt *time.Timer // redial wait timer
+}
+
+// Dial the Hyper-V socket at addr.
+//
+// See [HvsockDialer.Dial] for more information.
+func Dial(ctx context.Context, addr *HvsockAddr) (conn *HvsockConn, err error) {
+ return (&HvsockDialer{}).Dial(ctx, addr)
+}
+
+// Dial attempts to connect to the Hyper-V socket at addr, and returns a connection if successful.
+// Will attempt (HvsockDialer).Retries if dialing fails, waiting (HvsockDialer).RetryWait between
+// retries.
+//
+// Dialing can be cancelled either by providing (HvsockDialer).Deadline, or cancelling ctx.
+func (d *HvsockDialer) Dial(ctx context.Context, addr *HvsockAddr) (conn *HvsockConn, err error) {
+ op := "dial"
+ // create the conn early to use opErr()
+ conn = &HvsockConn{
+ remote: *addr,
+ }
+
+ if !d.Deadline.IsZero() {
+ var cancel context.CancelFunc
+ ctx, cancel = context.WithDeadline(ctx, d.Deadline)
+ defer cancel()
+ }
+
+ // preemptive timeout/cancellation check
+ if err = ctx.Err(); err != nil {
+ return nil, conn.opErr(op, err)
+ }
+
+ sock, err := newHVSocket()
+ if err != nil {
+ return nil, conn.opErr(op, err)
+ }
+ defer func() {
+ if sock != nil {
+ sock.Close()
+ }
+ }()
+
+ sa := addr.raw()
+ err = socket.Bind(windows.Handle(sock.handle), &sa)
+ if err != nil {
+ return nil, conn.opErr(op, os.NewSyscallError("bind", err))
+ }
+
+ c, err := sock.prepareIO()
+ if err != nil {
+ return nil, conn.opErr(op, err)
+ }
+ defer sock.wg.Done()
+ var bytes uint32
+ for i := uint(0); i <= d.Retries; i++ {
+ err = socket.ConnectEx(
+ windows.Handle(sock.handle),
+ &sa,
+ nil, // sendBuf
+ 0, // sendDataLen
+ &bytes,
+ (*windows.Overlapped)(unsafe.Pointer(&c.o)))
+ _, err = sock.asyncIO(c, nil, bytes, err)
+ if i < d.Retries && canRedial(err) {
+ if err = d.redialWait(ctx); err == nil {
+ continue
+ }
+ }
+ break
+ }
+ if err != nil {
+ return nil, conn.opErr(op, os.NewSyscallError("connectex", err))
+ }
+
+ // update the connection properties, so shutdown can be used
+ if err = windows.Setsockopt(
+ windows.Handle(sock.handle),
+ windows.SOL_SOCKET,
+ windows.SO_UPDATE_CONNECT_CONTEXT,
+ nil, // optvalue
+ 0, // optlen
+ ); err != nil {
+ return nil, conn.opErr(op, os.NewSyscallError("setsockopt", err))
+ }
+
+ // get the local name
+ var sal rawHvsockAddr
+ err = socket.GetSockName(windows.Handle(sock.handle), &sal)
+ if err != nil {
+ return nil, conn.opErr(op, os.NewSyscallError("getsockname", err))
+ }
+ conn.local.fromRaw(&sal)
+
+ // one last check for timeout, since asyncIO doesn't check the context
+ if err = ctx.Err(); err != nil {
+ return nil, conn.opErr(op, err)
+ }
+
+ conn.sock = sock
+ sock = nil
+
+ return conn, nil
+}
+
+// redialWait waits before attempting to redial, resetting the timer as appropriate.
+func (d *HvsockDialer) redialWait(ctx context.Context) (err error) {
+ if d.RetryWait == 0 {
+ return nil
+ }
+
+ if d.rt == nil {
+ d.rt = time.NewTimer(d.RetryWait)
+ } else {
+ // should already be stopped and drained
+ d.rt.Reset(d.RetryWait)
+ }
+
+ select {
+ case <-ctx.Done():
+ case <-d.rt.C:
+ return nil
+ }
+
+ // stop and drain the timer
+ if !d.rt.Stop() {
+ <-d.rt.C
+ }
+ return ctx.Err()
+}
+
+// assumes error is a plain, unwrapped syscall.Errno provided by direct syscall.
+func canRedial(err error) bool {
+ //nolint:errorlint // guaranteed to be an Errno
+ switch err {
+ case windows.WSAECONNREFUSED, windows.WSAENETUNREACH, windows.WSAETIMEDOUT,
+ windows.ERROR_CONNECTION_REFUSED, windows.ERROR_CONNECTION_UNAVAIL:
+ return true
+ default:
+ return false
+ }
+}
+
+func (conn *HvsockConn) opErr(op string, err error) error {
+ // translate from "file closed" to "socket closed"
+ if errors.Is(err, ErrFileClosed) {
+ err = socket.ErrSocketClosed
+ }
+ return &net.OpError{Op: op, Net: "hvsock", Source: &conn.local, Addr: &conn.remote, Err: err}
+}
+
+func (conn *HvsockConn) Read(b []byte) (int, error) {
+ c, err := conn.sock.prepareIO()
+ if err != nil {
+ return 0, conn.opErr("read", err)
+ }
+ defer conn.sock.wg.Done()
+ buf := syscall.WSABuf{Buf: &b[0], Len: uint32(len(b))}
+ var flags, bytes uint32
+ err = syscall.WSARecv(conn.sock.handle, &buf, 1, &bytes, &flags, &c.o, nil)
+ n, err := conn.sock.asyncIO(c, &conn.sock.readDeadline, bytes, err)
+ if err != nil {
+ var eno windows.Errno
+ if errors.As(err, &eno) {
+ err = os.NewSyscallError("wsarecv", eno)
+ }
+ return 0, conn.opErr("read", err)
+ } else if n == 0 {
+ err = io.EOF
+ }
+ return n, err
+}
+
+func (conn *HvsockConn) Write(b []byte) (int, error) {
+ t := 0
+ for len(b) != 0 {
+ n, err := conn.write(b)
+ if err != nil {
+ return t + n, err
+ }
+ t += n
+ b = b[n:]
+ }
+ return t, nil
+}
+
+func (conn *HvsockConn) write(b []byte) (int, error) {
+ c, err := conn.sock.prepareIO()
+ if err != nil {
+ return 0, conn.opErr("write", err)
+ }
+ defer conn.sock.wg.Done()
+ buf := syscall.WSABuf{Buf: &b[0], Len: uint32(len(b))}
+ var bytes uint32
+ err = syscall.WSASend(conn.sock.handle, &buf, 1, &bytes, 0, &c.o, nil)
+ n, err := conn.sock.asyncIO(c, &conn.sock.writeDeadline, bytes, err)
+ if err != nil {
+ var eno windows.Errno
+ if errors.As(err, &eno) {
+ err = os.NewSyscallError("wsasend", eno)
+ }
+ return 0, conn.opErr("write", err)
+ }
+ return n, err
+}
+
+// Close closes the socket connection, failing any pending read or write calls.
+func (conn *HvsockConn) Close() error {
+ return conn.sock.Close()
+}
+
+func (conn *HvsockConn) IsClosed() bool {
+ return conn.sock.IsClosed()
+}
+
+// shutdown disables sending or receiving on a socket.
+func (conn *HvsockConn) shutdown(how int) error {
+ if conn.IsClosed() {
+ return socket.ErrSocketClosed
+ }
+
+ err := syscall.Shutdown(conn.sock.handle, how)
+ if err != nil {
+ // If the connection was closed, shutdowns fail with "not connected"
+ if errors.Is(err, windows.WSAENOTCONN) ||
+ errors.Is(err, windows.WSAESHUTDOWN) {
+ err = socket.ErrSocketClosed
+ }
+ return os.NewSyscallError("shutdown", err)
+ }
+ return nil
+}
+
+// CloseRead shuts down the read end of the socket, preventing future read operations.
+func (conn *HvsockConn) CloseRead() error {
+ err := conn.shutdown(syscall.SHUT_RD)
+ if err != nil {
+ return conn.opErr("closeread", err)
+ }
+ return nil
+}
+
+// CloseWrite shuts down the write end of the socket, preventing future write operations and
+// notifying the other endpoint that no more data will be written.
+func (conn *HvsockConn) CloseWrite() error {
+ err := conn.shutdown(syscall.SHUT_WR)
+ if err != nil {
+ return conn.opErr("closewrite", err)
+ }
+ return nil
+}
+
+// LocalAddr returns the local address of the connection.
+func (conn *HvsockConn) LocalAddr() net.Addr {
+ return &conn.local
+}
+
+// RemoteAddr returns the remote address of the connection.
+func (conn *HvsockConn) RemoteAddr() net.Addr {
+ return &conn.remote
+}
+
+// SetDeadline implements the net.Conn SetDeadline method.
+func (conn *HvsockConn) SetDeadline(t time.Time) error {
+ // todo: implement `SetDeadline` for `win32File`
+ if err := conn.SetReadDeadline(t); err != nil {
+ return fmt.Errorf("set read deadline: %w", err)
+ }
+ if err := conn.SetWriteDeadline(t); err != nil {
+ return fmt.Errorf("set write deadline: %w", err)
+ }
+ return nil
+}
+
+// SetReadDeadline implements the net.Conn SetReadDeadline method.
+func (conn *HvsockConn) SetReadDeadline(t time.Time) error {
+ return conn.sock.SetReadDeadline(t)
+}
+
+// SetWriteDeadline implements the net.Conn SetWriteDeadline method.
+func (conn *HvsockConn) SetWriteDeadline(t time.Time) error {
+ return conn.sock.SetWriteDeadline(t)
+}
diff --git a/vendor/github.com/Microsoft/go-winio/internal/fs/doc.go b/vendor/github.com/Microsoft/go-winio/internal/fs/doc.go
new file mode 100644
index 0000000..1f65388
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/internal/fs/doc.go
@@ -0,0 +1,2 @@
+// This package contains Win32 filesystem functionality.
+package fs
diff --git a/vendor/github.com/Microsoft/go-winio/internal/fs/fs.go b/vendor/github.com/Microsoft/go-winio/internal/fs/fs.go
new file mode 100644
index 0000000..509b3ec
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/internal/fs/fs.go
@@ -0,0 +1,202 @@
+//go:build windows
+
+package fs
+
+import (
+ "golang.org/x/sys/windows"
+
+ "github.com/Microsoft/go-winio/internal/stringbuffer"
+)
+
+//go:generate go run github.com/Microsoft/go-winio/tools/mkwinsyscall -output zsyscall_windows.go fs.go
+
+// https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew
+//sys CreateFile(name string, access AccessMask, mode FileShareMode, sa *syscall.SecurityAttributes, createmode FileCreationDisposition, attrs FileFlagOrAttribute, templatefile windows.Handle) (handle windows.Handle, err error) [failretval==windows.InvalidHandle] = CreateFileW
+
+const NullHandle windows.Handle = 0
+
+// AccessMask defines standard, specific, and generic rights.
+//
+// Bitmask:
+// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
+// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
+// +---------------+---------------+-------------------------------+
+// |G|G|G|G|Resvd|A| StandardRights| SpecificRights |
+// |R|W|E|A| |S| | |
+// +-+-------------+---------------+-------------------------------+
+//
+// GR Generic Read
+// GW Generic Write
+// GE Generic Exectue
+// GA Generic All
+// Resvd Reserved
+// AS Access Security System
+//
+// https://learn.microsoft.com/en-us/windows/win32/secauthz/access-mask
+//
+// https://learn.microsoft.com/en-us/windows/win32/secauthz/generic-access-rights
+//
+// https://learn.microsoft.com/en-us/windows/win32/fileio/file-access-rights-constants
+type AccessMask = windows.ACCESS_MASK
+
+//nolint:revive // SNAKE_CASE is not idiomatic in Go, but aligned with Win32 API.
+const (
+ // Not actually any.
+ //
+ // For CreateFile: "query certain metadata such as file, directory, or device attributes without accessing that file or device"
+ // https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew#parameters
+ FILE_ANY_ACCESS AccessMask = 0
+
+ // Specific Object Access
+ // from ntioapi.h
+
+ FILE_READ_DATA AccessMask = (0x0001) // file & pipe
+ FILE_LIST_DIRECTORY AccessMask = (0x0001) // directory
+
+ FILE_WRITE_DATA AccessMask = (0x0002) // file & pipe
+ FILE_ADD_FILE AccessMask = (0x0002) // directory
+
+ FILE_APPEND_DATA AccessMask = (0x0004) // file
+ FILE_ADD_SUBDIRECTORY AccessMask = (0x0004) // directory
+ FILE_CREATE_PIPE_INSTANCE AccessMask = (0x0004) // named pipe
+
+ FILE_READ_EA AccessMask = (0x0008) // file & directory
+ FILE_READ_PROPERTIES AccessMask = FILE_READ_EA
+
+ FILE_WRITE_EA AccessMask = (0x0010) // file & directory
+ FILE_WRITE_PROPERTIES AccessMask = FILE_WRITE_EA
+
+ FILE_EXECUTE AccessMask = (0x0020) // file
+ FILE_TRAVERSE AccessMask = (0x0020) // directory
+
+ FILE_DELETE_CHILD AccessMask = (0x0040) // directory
+
+ FILE_READ_ATTRIBUTES AccessMask = (0x0080) // all
+
+ FILE_WRITE_ATTRIBUTES AccessMask = (0x0100) // all
+
+ FILE_ALL_ACCESS AccessMask = (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1FF)
+ FILE_GENERIC_READ AccessMask = (STANDARD_RIGHTS_READ | FILE_READ_DATA | FILE_READ_ATTRIBUTES | FILE_READ_EA | SYNCHRONIZE)
+ FILE_GENERIC_WRITE AccessMask = (STANDARD_RIGHTS_WRITE | FILE_WRITE_DATA | FILE_WRITE_ATTRIBUTES | FILE_WRITE_EA | FILE_APPEND_DATA | SYNCHRONIZE)
+ FILE_GENERIC_EXECUTE AccessMask = (STANDARD_RIGHTS_EXECUTE | FILE_READ_ATTRIBUTES | FILE_EXECUTE | SYNCHRONIZE)
+
+ SPECIFIC_RIGHTS_ALL AccessMask = 0x0000FFFF
+
+ // Standard Access
+ // from ntseapi.h
+
+ DELETE AccessMask = 0x0001_0000
+ READ_CONTROL AccessMask = 0x0002_0000
+ WRITE_DAC AccessMask = 0x0004_0000
+ WRITE_OWNER AccessMask = 0x0008_0000
+ SYNCHRONIZE AccessMask = 0x0010_0000
+
+ STANDARD_RIGHTS_REQUIRED AccessMask = 0x000F_0000
+
+ STANDARD_RIGHTS_READ AccessMask = READ_CONTROL
+ STANDARD_RIGHTS_WRITE AccessMask = READ_CONTROL
+ STANDARD_RIGHTS_EXECUTE AccessMask = READ_CONTROL
+
+ STANDARD_RIGHTS_ALL AccessMask = 0x001F_0000
+)
+
+type FileShareMode uint32
+
+//nolint:revive // SNAKE_CASE is not idiomatic in Go, but aligned with Win32 API.
+const (
+ FILE_SHARE_NONE FileShareMode = 0x00
+ FILE_SHARE_READ FileShareMode = 0x01
+ FILE_SHARE_WRITE FileShareMode = 0x02
+ FILE_SHARE_DELETE FileShareMode = 0x04
+ FILE_SHARE_VALID_FLAGS FileShareMode = 0x07
+)
+
+type FileCreationDisposition uint32
+
+//nolint:revive // SNAKE_CASE is not idiomatic in Go, but aligned with Win32 API.
+const (
+ // from winbase.h
+
+ CREATE_NEW FileCreationDisposition = 0x01
+ CREATE_ALWAYS FileCreationDisposition = 0x02
+ OPEN_EXISTING FileCreationDisposition = 0x03
+ OPEN_ALWAYS FileCreationDisposition = 0x04
+ TRUNCATE_EXISTING FileCreationDisposition = 0x05
+)
+
+// CreateFile and co. take flags or attributes together as one parameter.
+// Define alias until we can use generics to allow both
+
+// https://learn.microsoft.com/en-us/windows/win32/fileio/file-attribute-constants
+type FileFlagOrAttribute uint32
+
+//nolint:revive // SNAKE_CASE is not idiomatic in Go, but aligned with Win32 API.
+const ( // from winnt.h
+ FILE_FLAG_WRITE_THROUGH FileFlagOrAttribute = 0x8000_0000
+ FILE_FLAG_OVERLAPPED FileFlagOrAttribute = 0x4000_0000
+ FILE_FLAG_NO_BUFFERING FileFlagOrAttribute = 0x2000_0000
+ FILE_FLAG_RANDOM_ACCESS FileFlagOrAttribute = 0x1000_0000
+ FILE_FLAG_SEQUENTIAL_SCAN FileFlagOrAttribute = 0x0800_0000
+ FILE_FLAG_DELETE_ON_CLOSE FileFlagOrAttribute = 0x0400_0000
+ FILE_FLAG_BACKUP_SEMANTICS FileFlagOrAttribute = 0x0200_0000
+ FILE_FLAG_POSIX_SEMANTICS FileFlagOrAttribute = 0x0100_0000
+ FILE_FLAG_OPEN_REPARSE_POINT FileFlagOrAttribute = 0x0020_0000
+ FILE_FLAG_OPEN_NO_RECALL FileFlagOrAttribute = 0x0010_0000
+ FILE_FLAG_FIRST_PIPE_INSTANCE FileFlagOrAttribute = 0x0008_0000
+)
+
+type FileSQSFlag = FileFlagOrAttribute
+
+//nolint:revive // SNAKE_CASE is not idiomatic in Go, but aligned with Win32 API.
+const ( // from winbase.h
+ SECURITY_ANONYMOUS FileSQSFlag = FileSQSFlag(SecurityAnonymous << 16)
+ SECURITY_IDENTIFICATION FileSQSFlag = FileSQSFlag(SecurityIdentification << 16)
+ SECURITY_IMPERSONATION FileSQSFlag = FileSQSFlag(SecurityImpersonation << 16)
+ SECURITY_DELEGATION FileSQSFlag = FileSQSFlag(SecurityDelegation << 16)
+
+ SECURITY_SQOS_PRESENT FileSQSFlag = 0x00100000
+ SECURITY_VALID_SQOS_FLAGS FileSQSFlag = 0x001F0000
+)
+
+// GetFinalPathNameByHandle flags
+//
+// https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getfinalpathnamebyhandlew#parameters
+type GetFinalPathFlag uint32
+
+//nolint:revive // SNAKE_CASE is not idiomatic in Go, but aligned with Win32 API.
+const (
+ GetFinalPathDefaultFlag GetFinalPathFlag = 0x0
+
+ FILE_NAME_NORMALIZED GetFinalPathFlag = 0x0
+ FILE_NAME_OPENED GetFinalPathFlag = 0x8
+
+ VOLUME_NAME_DOS GetFinalPathFlag = 0x0
+ VOLUME_NAME_GUID GetFinalPathFlag = 0x1
+ VOLUME_NAME_NT GetFinalPathFlag = 0x2
+ VOLUME_NAME_NONE GetFinalPathFlag = 0x4
+)
+
+// getFinalPathNameByHandle facilitates calling the Windows API GetFinalPathNameByHandle
+// with the given handle and flags. It transparently takes care of creating a buffer of the
+// correct size for the call.
+//
+// https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getfinalpathnamebyhandlew
+func GetFinalPathNameByHandle(h windows.Handle, flags GetFinalPathFlag) (string, error) {
+ b := stringbuffer.NewWString()
+ //TODO: can loop infinitely if Win32 keeps returning the same (or a larger) n?
+ for {
+ n, err := windows.GetFinalPathNameByHandle(h, b.Pointer(), b.Cap(), uint32(flags))
+ if err != nil {
+ return "", err
+ }
+ // If the buffer wasn't large enough, n will be the total size needed (including null terminator).
+ // Resize and try again.
+ if n > b.Cap() {
+ b.ResizeTo(n)
+ continue
+ }
+ // If the buffer is large enough, n will be the size not including the null terminator.
+ // Convert to a Go string and return.
+ return b.String(), nil
+ }
+}
diff --git a/vendor/github.com/Microsoft/go-winio/internal/fs/security.go b/vendor/github.com/Microsoft/go-winio/internal/fs/security.go
new file mode 100644
index 0000000..81760ac
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/internal/fs/security.go
@@ -0,0 +1,12 @@
+package fs
+
+// https://learn.microsoft.com/en-us/windows/win32/api/winnt/ne-winnt-security_impersonation_level
+type SecurityImpersonationLevel int32 // C default enums underlying type is `int`, which is Go `int32`
+
+// Impersonation levels
+const (
+ SecurityAnonymous SecurityImpersonationLevel = 0
+ SecurityIdentification SecurityImpersonationLevel = 1
+ SecurityImpersonation SecurityImpersonationLevel = 2
+ SecurityDelegation SecurityImpersonationLevel = 3
+)
diff --git a/vendor/github.com/Microsoft/go-winio/internal/fs/zsyscall_windows.go b/vendor/github.com/Microsoft/go-winio/internal/fs/zsyscall_windows.go
new file mode 100644
index 0000000..e2f7bb2
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/internal/fs/zsyscall_windows.go
@@ -0,0 +1,64 @@
+//go:build windows
+
+// Code generated by 'go generate' using "github.com/Microsoft/go-winio/tools/mkwinsyscall"; DO NOT EDIT.
+
+package fs
+
+import (
+ "syscall"
+ "unsafe"
+
+ "golang.org/x/sys/windows"
+)
+
+var _ unsafe.Pointer
+
+// Do the interface allocations only once for common
+// Errno values.
+const (
+ errnoERROR_IO_PENDING = 997
+)
+
+var (
+ errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)
+ errERROR_EINVAL error = syscall.EINVAL
+)
+
+// errnoErr returns common boxed Errno values, to prevent
+// allocations at runtime.
+func errnoErr(e syscall.Errno) error {
+ switch e {
+ case 0:
+ return errERROR_EINVAL
+ case errnoERROR_IO_PENDING:
+ return errERROR_IO_PENDING
+ }
+ // TODO: add more here, after collecting data on the common
+ // error values see on Windows. (perhaps when running
+ // all.bat?)
+ return e
+}
+
+var (
+ modkernel32 = windows.NewLazySystemDLL("kernel32.dll")
+
+ procCreateFileW = modkernel32.NewProc("CreateFileW")
+)
+
+func CreateFile(name string, access AccessMask, mode FileShareMode, sa *syscall.SecurityAttributes, createmode FileCreationDisposition, attrs FileFlagOrAttribute, templatefile windows.Handle) (handle windows.Handle, err error) {
+ var _p0 *uint16
+ _p0, err = syscall.UTF16PtrFromString(name)
+ if err != nil {
+ return
+ }
+ return _CreateFile(_p0, access, mode, sa, createmode, attrs, templatefile)
+}
+
+func _CreateFile(name *uint16, access AccessMask, mode FileShareMode, sa *syscall.SecurityAttributes, createmode FileCreationDisposition, attrs FileFlagOrAttribute, templatefile windows.Handle) (handle windows.Handle, err error) {
+ r0, _, e1 := syscall.Syscall9(procCreateFileW.Addr(), 7, uintptr(unsafe.Pointer(name)), uintptr(access), uintptr(mode), uintptr(unsafe.Pointer(sa)), uintptr(createmode), uintptr(attrs), uintptr(templatefile), 0, 0)
+ handle = windows.Handle(r0)
+ if handle == windows.InvalidHandle {
+ err = errnoErr(e1)
+ }
+ return
+}
diff --git a/vendor/github.com/Microsoft/go-winio/internal/socket/rawaddr.go b/vendor/github.com/Microsoft/go-winio/internal/socket/rawaddr.go
new file mode 100644
index 0000000..7e82f9a
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/internal/socket/rawaddr.go
@@ -0,0 +1,20 @@
+package socket
+
+import (
+ "unsafe"
+)
+
+// RawSockaddr allows structs to be used with [Bind] and [ConnectEx]. The
+// struct must meet the Win32 sockaddr requirements specified here:
+// https://docs.microsoft.com/en-us/windows/win32/winsock/sockaddr-2
+//
+// Specifically, the struct size must be least larger than an int16 (unsigned short)
+// for the address family.
+type RawSockaddr interface {
+ // Sockaddr returns a pointer to the RawSockaddr and its struct size, allowing
+ // for the RawSockaddr's data to be overwritten by syscalls (if necessary).
+ //
+ // It is the callers responsibility to validate that the values are valid; invalid
+ // pointers or size can cause a panic.
+ Sockaddr() (unsafe.Pointer, int32, error)
+}
diff --git a/vendor/github.com/Microsoft/go-winio/internal/socket/socket.go b/vendor/github.com/Microsoft/go-winio/internal/socket/socket.go
new file mode 100644
index 0000000..aeb7b72
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/internal/socket/socket.go
@@ -0,0 +1,179 @@
+//go:build windows
+
+package socket
+
+import (
+ "errors"
+ "fmt"
+ "net"
+ "sync"
+ "syscall"
+ "unsafe"
+
+ "github.com/Microsoft/go-winio/pkg/guid"
+ "golang.org/x/sys/windows"
+)
+
+//go:generate go run github.com/Microsoft/go-winio/tools/mkwinsyscall -output zsyscall_windows.go socket.go
+
+//sys getsockname(s windows.Handle, name unsafe.Pointer, namelen *int32) (err error) [failretval==socketError] = ws2_32.getsockname
+//sys getpeername(s windows.Handle, name unsafe.Pointer, namelen *int32) (err error) [failretval==socketError] = ws2_32.getpeername
+//sys bind(s windows.Handle, name unsafe.Pointer, namelen int32) (err error) [failretval==socketError] = ws2_32.bind
+
+const socketError = uintptr(^uint32(0))
+
+var (
+ // todo(helsaawy): create custom error types to store the desired vs actual size and addr family?
+
+ ErrBufferSize = errors.New("buffer size")
+ ErrAddrFamily = errors.New("address family")
+ ErrInvalidPointer = errors.New("invalid pointer")
+ ErrSocketClosed = fmt.Errorf("socket closed: %w", net.ErrClosed)
+)
+
+// todo(helsaawy): replace these with generics, ie: GetSockName[S RawSockaddr](s windows.Handle) (S, error)
+
+// GetSockName writes the local address of socket s to the [RawSockaddr] rsa.
+// If rsa is not large enough, the [windows.WSAEFAULT] is returned.
+func GetSockName(s windows.Handle, rsa RawSockaddr) error {
+ ptr, l, err := rsa.Sockaddr()
+ if err != nil {
+ return fmt.Errorf("could not retrieve socket pointer and size: %w", err)
+ }
+
+ // although getsockname returns WSAEFAULT if the buffer is too small, it does not set
+ // &l to the correct size, so--apart from doubling the buffer repeatedly--there is no remedy
+ return getsockname(s, ptr, &l)
+}
+
+// GetPeerName returns the remote address the socket is connected to.
+//
+// See [GetSockName] for more information.
+func GetPeerName(s windows.Handle, rsa RawSockaddr) error {
+ ptr, l, err := rsa.Sockaddr()
+ if err != nil {
+ return fmt.Errorf("could not retrieve socket pointer and size: %w", err)
+ }
+
+ return getpeername(s, ptr, &l)
+}
+
+func Bind(s windows.Handle, rsa RawSockaddr) (err error) {
+ ptr, l, err := rsa.Sockaddr()
+ if err != nil {
+ return fmt.Errorf("could not retrieve socket pointer and size: %w", err)
+ }
+
+ return bind(s, ptr, l)
+}
+
+// "golang.org/x/sys/windows".ConnectEx and .Bind only accept internal implementations of the
+// their sockaddr interface, so they cannot be used with HvsockAddr
+// Replicate functionality here from
+// https://cs.opensource.google/go/x/sys/+/master:windows/syscall_windows.go
+
+// The function pointers to `AcceptEx`, `ConnectEx` and `GetAcceptExSockaddrs` must be loaded at
+// runtime via a WSAIoctl call:
+// https://docs.microsoft.com/en-us/windows/win32/api/Mswsock/nc-mswsock-lpfn_connectex#remarks
+
+type runtimeFunc struct {
+ id guid.GUID
+ once sync.Once
+ addr uintptr
+ err error
+}
+
+func (f *runtimeFunc) Load() error {
+ f.once.Do(func() {
+ var s windows.Handle
+ s, f.err = windows.Socket(windows.AF_INET, windows.SOCK_STREAM, windows.IPPROTO_TCP)
+ if f.err != nil {
+ return
+ }
+ defer windows.CloseHandle(s) //nolint:errcheck
+
+ var n uint32
+ f.err = windows.WSAIoctl(s,
+ windows.SIO_GET_EXTENSION_FUNCTION_POINTER,
+ (*byte)(unsafe.Pointer(&f.id)),
+ uint32(unsafe.Sizeof(f.id)),
+ (*byte)(unsafe.Pointer(&f.addr)),
+ uint32(unsafe.Sizeof(f.addr)),
+ &n,
+ nil, // overlapped
+ 0, // completionRoutine
+ )
+ })
+ return f.err
+}
+
+var (
+ // todo: add `AcceptEx` and `GetAcceptExSockaddrs`
+ WSAID_CONNECTEX = guid.GUID{ //revive:disable-line:var-naming ALL_CAPS
+ Data1: 0x25a207b9,
+ Data2: 0xddf3,
+ Data3: 0x4660,
+ Data4: [8]byte{0x8e, 0xe9, 0x76, 0xe5, 0x8c, 0x74, 0x06, 0x3e},
+ }
+
+ connectExFunc = runtimeFunc{id: WSAID_CONNECTEX}
+)
+
+func ConnectEx(
+ fd windows.Handle,
+ rsa RawSockaddr,
+ sendBuf *byte,
+ sendDataLen uint32,
+ bytesSent *uint32,
+ overlapped *windows.Overlapped,
+) error {
+ if err := connectExFunc.Load(); err != nil {
+ return fmt.Errorf("failed to load ConnectEx function pointer: %w", err)
+ }
+ ptr, n, err := rsa.Sockaddr()
+ if err != nil {
+ return err
+ }
+ return connectEx(fd, ptr, n, sendBuf, sendDataLen, bytesSent, overlapped)
+}
+
+// BOOL LpfnConnectex(
+// [in] SOCKET s,
+// [in] const sockaddr *name,
+// [in] int namelen,
+// [in, optional] PVOID lpSendBuffer,
+// [in] DWORD dwSendDataLength,
+// [out] LPDWORD lpdwBytesSent,
+// [in] LPOVERLAPPED lpOverlapped
+// )
+
+func connectEx(
+ s windows.Handle,
+ name unsafe.Pointer,
+ namelen int32,
+ sendBuf *byte,
+ sendDataLen uint32,
+ bytesSent *uint32,
+ overlapped *windows.Overlapped,
+) (err error) {
+ // todo: after upgrading to 1.18, switch from syscall.Syscall9 to syscall.SyscallN
+ r1, _, e1 := syscall.Syscall9(connectExFunc.addr,
+ 7,
+ uintptr(s),
+ uintptr(name),
+ uintptr(namelen),
+ uintptr(unsafe.Pointer(sendBuf)),
+ uintptr(sendDataLen),
+ uintptr(unsafe.Pointer(bytesSent)),
+ uintptr(unsafe.Pointer(overlapped)),
+ 0,
+ 0)
+ if r1 == 0 {
+ if e1 != 0 {
+ err = error(e1)
+ } else {
+ err = syscall.EINVAL
+ }
+ }
+ return err
+}
diff --git a/vendor/github.com/Microsoft/go-winio/internal/socket/zsyscall_windows.go b/vendor/github.com/Microsoft/go-winio/internal/socket/zsyscall_windows.go
new file mode 100644
index 0000000..6d2e1a9
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/internal/socket/zsyscall_windows.go
@@ -0,0 +1,72 @@
+//go:build windows
+
+// Code generated by 'go generate' using "github.com/Microsoft/go-winio/tools/mkwinsyscall"; DO NOT EDIT.
+
+package socket
+
+import (
+ "syscall"
+ "unsafe"
+
+ "golang.org/x/sys/windows"
+)
+
+var _ unsafe.Pointer
+
+// Do the interface allocations only once for common
+// Errno values.
+const (
+ errnoERROR_IO_PENDING = 997
+)
+
+var (
+ errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)
+ errERROR_EINVAL error = syscall.EINVAL
+)
+
+// errnoErr returns common boxed Errno values, to prevent
+// allocations at runtime.
+func errnoErr(e syscall.Errno) error {
+ switch e {
+ case 0:
+ return errERROR_EINVAL
+ case errnoERROR_IO_PENDING:
+ return errERROR_IO_PENDING
+ }
+ // TODO: add more here, after collecting data on the common
+ // error values see on Windows. (perhaps when running
+ // all.bat?)
+ return e
+}
+
+var (
+ modws2_32 = windows.NewLazySystemDLL("ws2_32.dll")
+
+ procbind = modws2_32.NewProc("bind")
+ procgetpeername = modws2_32.NewProc("getpeername")
+ procgetsockname = modws2_32.NewProc("getsockname")
+)
+
+func bind(s windows.Handle, name unsafe.Pointer, namelen int32) (err error) {
+ r1, _, e1 := syscall.Syscall(procbind.Addr(), 3, uintptr(s), uintptr(name), uintptr(namelen))
+ if r1 == socketError {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func getpeername(s windows.Handle, name unsafe.Pointer, namelen *int32) (err error) {
+ r1, _, e1 := syscall.Syscall(procgetpeername.Addr(), 3, uintptr(s), uintptr(name), uintptr(unsafe.Pointer(namelen)))
+ if r1 == socketError {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func getsockname(s windows.Handle, name unsafe.Pointer, namelen *int32) (err error) {
+ r1, _, e1 := syscall.Syscall(procgetsockname.Addr(), 3, uintptr(s), uintptr(name), uintptr(unsafe.Pointer(namelen)))
+ if r1 == socketError {
+ err = errnoErr(e1)
+ }
+ return
+}
diff --git a/vendor/github.com/Microsoft/go-winio/internal/stringbuffer/wstring.go b/vendor/github.com/Microsoft/go-winio/internal/stringbuffer/wstring.go
new file mode 100644
index 0000000..7ad5057
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/internal/stringbuffer/wstring.go
@@ -0,0 +1,132 @@
+package stringbuffer
+
+import (
+ "sync"
+ "unicode/utf16"
+)
+
+// TODO: worth exporting and using in mkwinsyscall?
+
+// Uint16BufferSize is the buffer size in the pool, chosen somewhat arbitrarily to accommodate
+// large path strings:
+// MAX_PATH (260) + size of volume GUID prefix (49) + null terminator = 310.
+const MinWStringCap = 310
+
+// use *[]uint16 since []uint16 creates an extra allocation where the slice header
+// is copied to heap and then referenced via pointer in the interface header that sync.Pool
+// stores.
+var pathPool = sync.Pool{ // if go1.18+ adds Pool[T], use that to store []uint16 directly
+ New: func() interface{} {
+ b := make([]uint16, MinWStringCap)
+ return &b
+ },
+}
+
+func newBuffer() []uint16 { return *(pathPool.Get().(*[]uint16)) }
+
+// freeBuffer copies the slice header data, and puts a pointer to that in the pool.
+// This avoids taking a pointer to the slice header in WString, which can be set to nil.
+func freeBuffer(b []uint16) { pathPool.Put(&b) }
+
+// WString is a wide string buffer ([]uint16) meant for storing UTF-16 encoded strings
+// for interacting with Win32 APIs.
+// Sizes are specified as uint32 and not int.
+//
+// It is not thread safe.
+type WString struct {
+ // type-def allows casting to []uint16 directly, use struct to prevent that and allow adding fields in the future.
+
+ // raw buffer
+ b []uint16
+}
+
+// NewWString returns a [WString] allocated from a shared pool with an
+// initial capacity of at least [MinWStringCap].
+// Since the buffer may have been previously used, its contents are not guaranteed to be empty.
+//
+// The buffer should be freed via [WString.Free]
+func NewWString() *WString {
+ return &WString{
+ b: newBuffer(),
+ }
+}
+
+func (b *WString) Free() {
+ if b.empty() {
+ return
+ }
+ freeBuffer(b.b)
+ b.b = nil
+}
+
+// ResizeTo grows the buffer to at least c and returns the new capacity, freeing the
+// previous buffer back into pool.
+func (b *WString) ResizeTo(c uint32) uint32 {
+ // allready sufficient (or n is 0)
+ if c <= b.Cap() {
+ return b.Cap()
+ }
+
+ if c <= MinWStringCap {
+ c = MinWStringCap
+ }
+ // allocate at-least double buffer size, as is done in [bytes.Buffer] and other places
+ if c <= 2*b.Cap() {
+ c = 2 * b.Cap()
+ }
+
+ b2 := make([]uint16, c)
+ if !b.empty() {
+ copy(b2, b.b)
+ freeBuffer(b.b)
+ }
+ b.b = b2
+ return c
+}
+
+// Buffer returns the underlying []uint16 buffer.
+func (b *WString) Buffer() []uint16 {
+ if b.empty() {
+ return nil
+ }
+ return b.b
+}
+
+// Pointer returns a pointer to the first uint16 in the buffer.
+// If the [WString.Free] has already been called, the pointer will be nil.
+func (b *WString) Pointer() *uint16 {
+ if b.empty() {
+ return nil
+ }
+ return &b.b[0]
+}
+
+// String returns the returns the UTF-8 encoding of the UTF-16 string in the buffer.
+//
+// It assumes that the data is null-terminated.
+func (b *WString) String() string {
+ // Using [windows.UTF16ToString] would require importing "golang.org/x/sys/windows"
+ // and would make this code Windows-only, which makes no sense.
+ // So copy UTF16ToString code into here.
+ // If other windows-specific code is added, switch to [windows.UTF16ToString]
+
+ s := b.b
+ for i, v := range s {
+ if v == 0 {
+ s = s[:i]
+ break
+ }
+ }
+ return string(utf16.Decode(s))
+}
+
+// Cap returns the underlying buffer capacity.
+func (b *WString) Cap() uint32 {
+ if b.empty() {
+ return 0
+ }
+ return b.cap()
+}
+
+func (b *WString) cap() uint32 { return uint32(cap(b.b)) }
+func (b *WString) empty() bool { return b == nil || b.cap() == 0 }
diff --git a/vendor/github.com/Microsoft/go-winio/pipe.go b/vendor/github.com/Microsoft/go-winio/pipe.go
new file mode 100644
index 0000000..25cc811
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/pipe.go
@@ -0,0 +1,525 @@
+//go:build windows
+// +build windows
+
+package winio
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "io"
+ "net"
+ "os"
+ "runtime"
+ "syscall"
+ "time"
+ "unsafe"
+
+ "golang.org/x/sys/windows"
+
+ "github.com/Microsoft/go-winio/internal/fs"
+)
+
+//sys connectNamedPipe(pipe syscall.Handle, o *syscall.Overlapped) (err error) = ConnectNamedPipe
+//sys createNamedPipe(name string, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *syscall.SecurityAttributes) (handle syscall.Handle, err error) [failretval==syscall.InvalidHandle] = CreateNamedPipeW
+//sys getNamedPipeInfo(pipe syscall.Handle, flags *uint32, outSize *uint32, inSize *uint32, maxInstances *uint32) (err error) = GetNamedPipeInfo
+//sys getNamedPipeHandleState(pipe syscall.Handle, state *uint32, curInstances *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32, userName *uint16, maxUserNameSize uint32) (err error) = GetNamedPipeHandleStateW
+//sys localAlloc(uFlags uint32, length uint32) (ptr uintptr) = LocalAlloc
+//sys ntCreateNamedPipeFile(pipe *syscall.Handle, access uint32, oa *objectAttributes, iosb *ioStatusBlock, share uint32, disposition uint32, options uint32, typ uint32, readMode uint32, completionMode uint32, maxInstances uint32, inboundQuota uint32, outputQuota uint32, timeout *int64) (status ntStatus) = ntdll.NtCreateNamedPipeFile
+//sys rtlNtStatusToDosError(status ntStatus) (winerr error) = ntdll.RtlNtStatusToDosErrorNoTeb
+//sys rtlDosPathNameToNtPathName(name *uint16, ntName *unicodeString, filePart uintptr, reserved uintptr) (status ntStatus) = ntdll.RtlDosPathNameToNtPathName_U
+//sys rtlDefaultNpAcl(dacl *uintptr) (status ntStatus) = ntdll.RtlDefaultNpAcl
+
+type ioStatusBlock struct {
+ Status, Information uintptr
+}
+
+type objectAttributes struct {
+ Length uintptr
+ RootDirectory uintptr
+ ObjectName *unicodeString
+ Attributes uintptr
+ SecurityDescriptor *securityDescriptor
+ SecurityQoS uintptr
+}
+
+type unicodeString struct {
+ Length uint16
+ MaximumLength uint16
+ Buffer uintptr
+}
+
+type securityDescriptor struct {
+ Revision byte
+ Sbz1 byte
+ Control uint16
+ Owner uintptr
+ Group uintptr
+ Sacl uintptr //revive:disable-line:var-naming SACL, not Sacl
+ Dacl uintptr //revive:disable-line:var-naming DACL, not Dacl
+}
+
+type ntStatus int32
+
+func (status ntStatus) Err() error {
+ if status >= 0 {
+ return nil
+ }
+ return rtlNtStatusToDosError(status)
+}
+
+var (
+ // ErrPipeListenerClosed is returned for pipe operations on listeners that have been closed.
+ ErrPipeListenerClosed = net.ErrClosed
+
+ errPipeWriteClosed = errors.New("pipe has been closed for write")
+)
+
+type win32Pipe struct {
+ *win32File
+ path string
+}
+
+type win32MessageBytePipe struct {
+ win32Pipe
+ writeClosed bool
+ readEOF bool
+}
+
+type pipeAddress string
+
+func (f *win32Pipe) LocalAddr() net.Addr {
+ return pipeAddress(f.path)
+}
+
+func (f *win32Pipe) RemoteAddr() net.Addr {
+ return pipeAddress(f.path)
+}
+
+func (f *win32Pipe) SetDeadline(t time.Time) error {
+ if err := f.SetReadDeadline(t); err != nil {
+ return err
+ }
+ return f.SetWriteDeadline(t)
+}
+
+// CloseWrite closes the write side of a message pipe in byte mode.
+func (f *win32MessageBytePipe) CloseWrite() error {
+ if f.writeClosed {
+ return errPipeWriteClosed
+ }
+ err := f.win32File.Flush()
+ if err != nil {
+ return err
+ }
+ _, err = f.win32File.Write(nil)
+ if err != nil {
+ return err
+ }
+ f.writeClosed = true
+ return nil
+}
+
+// Write writes bytes to a message pipe in byte mode. Zero-byte writes are ignored, since
+// they are used to implement CloseWrite().
+func (f *win32MessageBytePipe) Write(b []byte) (int, error) {
+ if f.writeClosed {
+ return 0, errPipeWriteClosed
+ }
+ if len(b) == 0 {
+ return 0, nil
+ }
+ return f.win32File.Write(b)
+}
+
+// Read reads bytes from a message pipe in byte mode. A read of a zero-byte message on a message
+// mode pipe will return io.EOF, as will all subsequent reads.
+func (f *win32MessageBytePipe) Read(b []byte) (int, error) {
+ if f.readEOF {
+ return 0, io.EOF
+ }
+ n, err := f.win32File.Read(b)
+ if err == io.EOF { //nolint:errorlint
+ // If this was the result of a zero-byte read, then
+ // it is possible that the read was due to a zero-size
+ // message. Since we are simulating CloseWrite with a
+ // zero-byte message, ensure that all future Read() calls
+ // also return EOF.
+ f.readEOF = true
+ } else if err == syscall.ERROR_MORE_DATA { //nolint:errorlint // err is Errno
+ // ERROR_MORE_DATA indicates that the pipe's read mode is message mode
+ // and the message still has more bytes. Treat this as a success, since
+ // this package presents all named pipes as byte streams.
+ err = nil
+ }
+ return n, err
+}
+
+func (pipeAddress) Network() string {
+ return "pipe"
+}
+
+func (s pipeAddress) String() string {
+ return string(s)
+}
+
+// tryDialPipe attempts to dial the pipe at `path` until `ctx` cancellation or timeout.
+func tryDialPipe(ctx context.Context, path *string, access fs.AccessMask) (syscall.Handle, error) {
+ for {
+ select {
+ case <-ctx.Done():
+ return syscall.Handle(0), ctx.Err()
+ default:
+ wh, err := fs.CreateFile(*path,
+ access,
+ 0, // mode
+ nil, // security attributes
+ fs.OPEN_EXISTING,
+ fs.FILE_FLAG_OVERLAPPED|fs.SECURITY_SQOS_PRESENT|fs.SECURITY_ANONYMOUS,
+ 0, // template file handle
+ )
+ h := syscall.Handle(wh)
+ if err == nil {
+ return h, nil
+ }
+ if err != windows.ERROR_PIPE_BUSY { //nolint:errorlint // err is Errno
+ return h, &os.PathError{Err: err, Op: "open", Path: *path}
+ }
+ // Wait 10 msec and try again. This is a rather simplistic
+ // view, as we always try each 10 milliseconds.
+ time.Sleep(10 * time.Millisecond)
+ }
+ }
+}
+
+// DialPipe connects to a named pipe by path, timing out if the connection
+// takes longer than the specified duration. If timeout is nil, then we use
+// a default timeout of 2 seconds. (We do not use WaitNamedPipe.)
+func DialPipe(path string, timeout *time.Duration) (net.Conn, error) {
+ var absTimeout time.Time
+ if timeout != nil {
+ absTimeout = time.Now().Add(*timeout)
+ } else {
+ absTimeout = time.Now().Add(2 * time.Second)
+ }
+ ctx, cancel := context.WithDeadline(context.Background(), absTimeout)
+ defer cancel()
+ conn, err := DialPipeContext(ctx, path)
+ if errors.Is(err, context.DeadlineExceeded) {
+ return nil, ErrTimeout
+ }
+ return conn, err
+}
+
+// DialPipeContext attempts to connect to a named pipe by `path` until `ctx`
+// cancellation or timeout.
+func DialPipeContext(ctx context.Context, path string) (net.Conn, error) {
+ return DialPipeAccess(ctx, path, syscall.GENERIC_READ|syscall.GENERIC_WRITE)
+}
+
+// DialPipeAccess attempts to connect to a named pipe by `path` with `access` until `ctx`
+// cancellation or timeout.
+func DialPipeAccess(ctx context.Context, path string, access uint32) (net.Conn, error) {
+ var err error
+ var h syscall.Handle
+ h, err = tryDialPipe(ctx, &path, fs.AccessMask(access))
+ if err != nil {
+ return nil, err
+ }
+
+ var flags uint32
+ err = getNamedPipeInfo(h, &flags, nil, nil, nil)
+ if err != nil {
+ return nil, err
+ }
+
+ f, err := makeWin32File(h)
+ if err != nil {
+ syscall.Close(h)
+ return nil, err
+ }
+
+ // If the pipe is in message mode, return a message byte pipe, which
+ // supports CloseWrite().
+ if flags&windows.PIPE_TYPE_MESSAGE != 0 {
+ return &win32MessageBytePipe{
+ win32Pipe: win32Pipe{win32File: f, path: path},
+ }, nil
+ }
+ return &win32Pipe{win32File: f, path: path}, nil
+}
+
+type acceptResponse struct {
+ f *win32File
+ err error
+}
+
+type win32PipeListener struct {
+ firstHandle syscall.Handle
+ path string
+ config PipeConfig
+ acceptCh chan (chan acceptResponse)
+ closeCh chan int
+ doneCh chan int
+}
+
+func makeServerPipeHandle(path string, sd []byte, c *PipeConfig, first bool) (syscall.Handle, error) {
+ path16, err := syscall.UTF16FromString(path)
+ if err != nil {
+ return 0, &os.PathError{Op: "open", Path: path, Err: err}
+ }
+
+ var oa objectAttributes
+ oa.Length = unsafe.Sizeof(oa)
+
+ var ntPath unicodeString
+ if err := rtlDosPathNameToNtPathName(&path16[0],
+ &ntPath,
+ 0,
+ 0,
+ ).Err(); err != nil {
+ return 0, &os.PathError{Op: "open", Path: path, Err: err}
+ }
+ defer localFree(ntPath.Buffer)
+ oa.ObjectName = &ntPath
+ oa.Attributes = windows.OBJ_CASE_INSENSITIVE
+
+ // The security descriptor is only needed for the first pipe.
+ if first {
+ if sd != nil {
+ l := uint32(len(sd))
+ sdb := localAlloc(0, l)
+ defer localFree(sdb)
+ copy((*[0xffff]byte)(unsafe.Pointer(sdb))[:], sd)
+ oa.SecurityDescriptor = (*securityDescriptor)(unsafe.Pointer(sdb))
+ } else {
+ // Construct the default named pipe security descriptor.
+ var dacl uintptr
+ if err := rtlDefaultNpAcl(&dacl).Err(); err != nil {
+ return 0, fmt.Errorf("getting default named pipe ACL: %w", err)
+ }
+ defer localFree(dacl)
+
+ sdb := &securityDescriptor{
+ Revision: 1,
+ Control: windows.SE_DACL_PRESENT,
+ Dacl: dacl,
+ }
+ oa.SecurityDescriptor = sdb
+ }
+ }
+
+ typ := uint32(windows.FILE_PIPE_REJECT_REMOTE_CLIENTS)
+ if c.MessageMode {
+ typ |= windows.FILE_PIPE_MESSAGE_TYPE
+ }
+
+ disposition := uint32(windows.FILE_OPEN)
+ access := uint32(syscall.GENERIC_READ | syscall.GENERIC_WRITE | syscall.SYNCHRONIZE)
+ if first {
+ disposition = windows.FILE_CREATE
+ // By not asking for read or write access, the named pipe file system
+ // will put this pipe into an initially disconnected state, blocking
+ // client connections until the next call with first == false.
+ access = syscall.SYNCHRONIZE
+ }
+
+ timeout := int64(-50 * 10000) // 50ms
+
+ var (
+ h syscall.Handle
+ iosb ioStatusBlock
+ )
+ err = ntCreateNamedPipeFile(&h,
+ access,
+ &oa,
+ &iosb,
+ syscall.FILE_SHARE_READ|syscall.FILE_SHARE_WRITE,
+ disposition,
+ 0,
+ typ,
+ 0,
+ 0,
+ 0xffffffff,
+ uint32(c.InputBufferSize),
+ uint32(c.OutputBufferSize),
+ &timeout).Err()
+ if err != nil {
+ return 0, &os.PathError{Op: "open", Path: path, Err: err}
+ }
+
+ runtime.KeepAlive(ntPath)
+ return h, nil
+}
+
+func (l *win32PipeListener) makeServerPipe() (*win32File, error) {
+ h, err := makeServerPipeHandle(l.path, nil, &l.config, false)
+ if err != nil {
+ return nil, err
+ }
+ f, err := makeWin32File(h)
+ if err != nil {
+ syscall.Close(h)
+ return nil, err
+ }
+ return f, nil
+}
+
+func (l *win32PipeListener) makeConnectedServerPipe() (*win32File, error) {
+ p, err := l.makeServerPipe()
+ if err != nil {
+ return nil, err
+ }
+
+ // Wait for the client to connect.
+ ch := make(chan error)
+ go func(p *win32File) {
+ ch <- connectPipe(p)
+ }(p)
+
+ select {
+ case err = <-ch:
+ if err != nil {
+ p.Close()
+ p = nil
+ }
+ case <-l.closeCh:
+ // Abort the connect request by closing the handle.
+ p.Close()
+ p = nil
+ err = <-ch
+ if err == nil || err == ErrFileClosed { //nolint:errorlint // err is Errno
+ err = ErrPipeListenerClosed
+ }
+ }
+ return p, err
+}
+
+func (l *win32PipeListener) listenerRoutine() {
+ closed := false
+ for !closed {
+ select {
+ case <-l.closeCh:
+ closed = true
+ case responseCh := <-l.acceptCh:
+ var (
+ p *win32File
+ err error
+ )
+ for {
+ p, err = l.makeConnectedServerPipe()
+ // If the connection was immediately closed by the client, try
+ // again.
+ if err != windows.ERROR_NO_DATA { //nolint:errorlint // err is Errno
+ break
+ }
+ }
+ responseCh <- acceptResponse{p, err}
+ closed = err == ErrPipeListenerClosed //nolint:errorlint // err is Errno
+ }
+ }
+ syscall.Close(l.firstHandle)
+ l.firstHandle = 0
+ // Notify Close() and Accept() callers that the handle has been closed.
+ close(l.doneCh)
+}
+
+// PipeConfig contain configuration for the pipe listener.
+type PipeConfig struct {
+ // SecurityDescriptor contains a Windows security descriptor in SDDL format.
+ SecurityDescriptor string
+
+ // MessageMode determines whether the pipe is in byte or message mode. In either
+ // case the pipe is read in byte mode by default. The only practical difference in
+ // this implementation is that CloseWrite() is only supported for message mode pipes;
+ // CloseWrite() is implemented as a zero-byte write, but zero-byte writes are only
+ // transferred to the reader (and returned as io.EOF in this implementation)
+ // when the pipe is in message mode.
+ MessageMode bool
+
+ // InputBufferSize specifies the size of the input buffer, in bytes.
+ InputBufferSize int32
+
+ // OutputBufferSize specifies the size of the output buffer, in bytes.
+ OutputBufferSize int32
+}
+
+// ListenPipe creates a listener on a Windows named pipe path, e.g. \\.\pipe\mypipe.
+// The pipe must not already exist.
+func ListenPipe(path string, c *PipeConfig) (net.Listener, error) {
+ var (
+ sd []byte
+ err error
+ )
+ if c == nil {
+ c = &PipeConfig{}
+ }
+ if c.SecurityDescriptor != "" {
+ sd, err = SddlToSecurityDescriptor(c.SecurityDescriptor)
+ if err != nil {
+ return nil, err
+ }
+ }
+ h, err := makeServerPipeHandle(path, sd, c, true)
+ if err != nil {
+ return nil, err
+ }
+ l := &win32PipeListener{
+ firstHandle: h,
+ path: path,
+ config: *c,
+ acceptCh: make(chan (chan acceptResponse)),
+ closeCh: make(chan int),
+ doneCh: make(chan int),
+ }
+ go l.listenerRoutine()
+ return l, nil
+}
+
+func connectPipe(p *win32File) error {
+ c, err := p.prepareIO()
+ if err != nil {
+ return err
+ }
+ defer p.wg.Done()
+
+ err = connectNamedPipe(p.handle, &c.o)
+ _, err = p.asyncIO(c, nil, 0, err)
+ if err != nil && err != windows.ERROR_PIPE_CONNECTED { //nolint:errorlint // err is Errno
+ return err
+ }
+ return nil
+}
+
+func (l *win32PipeListener) Accept() (net.Conn, error) {
+ ch := make(chan acceptResponse)
+ select {
+ case l.acceptCh <- ch:
+ response := <-ch
+ err := response.err
+ if err != nil {
+ return nil, err
+ }
+ if l.config.MessageMode {
+ return &win32MessageBytePipe{
+ win32Pipe: win32Pipe{win32File: response.f, path: l.path},
+ }, nil
+ }
+ return &win32Pipe{win32File: response.f, path: l.path}, nil
+ case <-l.doneCh:
+ return nil, ErrPipeListenerClosed
+ }
+}
+
+func (l *win32PipeListener) Close() error {
+ select {
+ case l.closeCh <- 1:
+ <-l.doneCh
+ case <-l.doneCh:
+ }
+ return nil
+}
+
+func (l *win32PipeListener) Addr() net.Addr {
+ return pipeAddress(l.path)
+}
diff --git a/vendor/github.com/Microsoft/go-winio/pkg/guid/guid.go b/vendor/github.com/Microsoft/go-winio/pkg/guid/guid.go
new file mode 100644
index 0000000..48ce4e9
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/pkg/guid/guid.go
@@ -0,0 +1,232 @@
+// Package guid provides a GUID type. The backing structure for a GUID is
+// identical to that used by the golang.org/x/sys/windows GUID type.
+// There are two main binary encodings used for a GUID, the big-endian encoding,
+// and the Windows (mixed-endian) encoding. See here for details:
+// https://en.wikipedia.org/wiki/Universally_unique_identifier#Encoding
+package guid
+
+import (
+ "crypto/rand"
+ "crypto/sha1" //nolint:gosec // not used for secure application
+ "encoding"
+ "encoding/binary"
+ "fmt"
+ "strconv"
+)
+
+//go:generate go run golang.org/x/tools/cmd/stringer -type=Variant -trimprefix=Variant -linecomment
+
+// Variant specifies which GUID variant (or "type") of the GUID. It determines
+// how the entirety of the rest of the GUID is interpreted.
+type Variant uint8
+
+// The variants specified by RFC 4122 section 4.1.1.
+const (
+ // VariantUnknown specifies a GUID variant which does not conform to one of
+ // the variant encodings specified in RFC 4122.
+ VariantUnknown Variant = iota
+ VariantNCS
+ VariantRFC4122 // RFC 4122
+ VariantMicrosoft
+ VariantFuture
+)
+
+// Version specifies how the bits in the GUID were generated. For instance, a
+// version 4 GUID is randomly generated, and a version 5 is generated from the
+// hash of an input string.
+type Version uint8
+
+func (v Version) String() string {
+ return strconv.FormatUint(uint64(v), 10)
+}
+
+var _ = (encoding.TextMarshaler)(GUID{})
+var _ = (encoding.TextUnmarshaler)(&GUID{})
+
+// NewV4 returns a new version 4 (pseudorandom) GUID, as defined by RFC 4122.
+func NewV4() (GUID, error) {
+ var b [16]byte
+ if _, err := rand.Read(b[:]); err != nil {
+ return GUID{}, err
+ }
+
+ g := FromArray(b)
+ g.setVersion(4) // Version 4 means randomly generated.
+ g.setVariant(VariantRFC4122)
+
+ return g, nil
+}
+
+// NewV5 returns a new version 5 (generated from a string via SHA-1 hashing)
+// GUID, as defined by RFC 4122. The RFC is unclear on the encoding of the name,
+// and the sample code treats it as a series of bytes, so we do the same here.
+//
+// Some implementations, such as those found on Windows, treat the name as a
+// big-endian UTF16 stream of bytes. If that is desired, the string can be
+// encoded as such before being passed to this function.
+func NewV5(namespace GUID, name []byte) (GUID, error) {
+ b := sha1.New() //nolint:gosec // not used for secure application
+ namespaceBytes := namespace.ToArray()
+ b.Write(namespaceBytes[:])
+ b.Write(name)
+
+ a := [16]byte{}
+ copy(a[:], b.Sum(nil))
+
+ g := FromArray(a)
+ g.setVersion(5) // Version 5 means generated from a string.
+ g.setVariant(VariantRFC4122)
+
+ return g, nil
+}
+
+func fromArray(b [16]byte, order binary.ByteOrder) GUID {
+ var g GUID
+ g.Data1 = order.Uint32(b[0:4])
+ g.Data2 = order.Uint16(b[4:6])
+ g.Data3 = order.Uint16(b[6:8])
+ copy(g.Data4[:], b[8:16])
+ return g
+}
+
+func (g GUID) toArray(order binary.ByteOrder) [16]byte {
+ b := [16]byte{}
+ order.PutUint32(b[0:4], g.Data1)
+ order.PutUint16(b[4:6], g.Data2)
+ order.PutUint16(b[6:8], g.Data3)
+ copy(b[8:16], g.Data4[:])
+ return b
+}
+
+// FromArray constructs a GUID from a big-endian encoding array of 16 bytes.
+func FromArray(b [16]byte) GUID {
+ return fromArray(b, binary.BigEndian)
+}
+
+// ToArray returns an array of 16 bytes representing the GUID in big-endian
+// encoding.
+func (g GUID) ToArray() [16]byte {
+ return g.toArray(binary.BigEndian)
+}
+
+// FromWindowsArray constructs a GUID from a Windows encoding array of bytes.
+func FromWindowsArray(b [16]byte) GUID {
+ return fromArray(b, binary.LittleEndian)
+}
+
+// ToWindowsArray returns an array of 16 bytes representing the GUID in Windows
+// encoding.
+func (g GUID) ToWindowsArray() [16]byte {
+ return g.toArray(binary.LittleEndian)
+}
+
+func (g GUID) String() string {
+ return fmt.Sprintf(
+ "%08x-%04x-%04x-%04x-%012x",
+ g.Data1,
+ g.Data2,
+ g.Data3,
+ g.Data4[:2],
+ g.Data4[2:])
+}
+
+// FromString parses a string containing a GUID and returns the GUID. The only
+// format currently supported is the `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`
+// format.
+func FromString(s string) (GUID, error) {
+ if len(s) != 36 {
+ return GUID{}, fmt.Errorf("invalid GUID %q", s)
+ }
+ if s[8] != '-' || s[13] != '-' || s[18] != '-' || s[23] != '-' {
+ return GUID{}, fmt.Errorf("invalid GUID %q", s)
+ }
+
+ var g GUID
+
+ data1, err := strconv.ParseUint(s[0:8], 16, 32)
+ if err != nil {
+ return GUID{}, fmt.Errorf("invalid GUID %q", s)
+ }
+ g.Data1 = uint32(data1)
+
+ data2, err := strconv.ParseUint(s[9:13], 16, 16)
+ if err != nil {
+ return GUID{}, fmt.Errorf("invalid GUID %q", s)
+ }
+ g.Data2 = uint16(data2)
+
+ data3, err := strconv.ParseUint(s[14:18], 16, 16)
+ if err != nil {
+ return GUID{}, fmt.Errorf("invalid GUID %q", s)
+ }
+ g.Data3 = uint16(data3)
+
+ for i, x := range []int{19, 21, 24, 26, 28, 30, 32, 34} {
+ v, err := strconv.ParseUint(s[x:x+2], 16, 8)
+ if err != nil {
+ return GUID{}, fmt.Errorf("invalid GUID %q", s)
+ }
+ g.Data4[i] = uint8(v)
+ }
+
+ return g, nil
+}
+
+func (g *GUID) setVariant(v Variant) {
+ d := g.Data4[0]
+ switch v {
+ case VariantNCS:
+ d = (d & 0x7f)
+ case VariantRFC4122:
+ d = (d & 0x3f) | 0x80
+ case VariantMicrosoft:
+ d = (d & 0x1f) | 0xc0
+ case VariantFuture:
+ d = (d & 0x0f) | 0xe0
+ case VariantUnknown:
+ fallthrough
+ default:
+ panic(fmt.Sprintf("invalid variant: %d", v))
+ }
+ g.Data4[0] = d
+}
+
+// Variant returns the GUID variant, as defined in RFC 4122.
+func (g GUID) Variant() Variant {
+ b := g.Data4[0]
+ if b&0x80 == 0 {
+ return VariantNCS
+ } else if b&0xc0 == 0x80 {
+ return VariantRFC4122
+ } else if b&0xe0 == 0xc0 {
+ return VariantMicrosoft
+ } else if b&0xe0 == 0xe0 {
+ return VariantFuture
+ }
+ return VariantUnknown
+}
+
+func (g *GUID) setVersion(v Version) {
+ g.Data3 = (g.Data3 & 0x0fff) | (uint16(v) << 12)
+}
+
+// Version returns the GUID version, as defined in RFC 4122.
+func (g GUID) Version() Version {
+ return Version((g.Data3 & 0xF000) >> 12)
+}
+
+// MarshalText returns the textual representation of the GUID.
+func (g GUID) MarshalText() ([]byte, error) {
+ return []byte(g.String()), nil
+}
+
+// UnmarshalText takes the textual representation of a GUID, and unmarhals it
+// into this GUID.
+func (g *GUID) UnmarshalText(text []byte) error {
+ g2, err := FromString(string(text))
+ if err != nil {
+ return err
+ }
+ *g = g2
+ return nil
+}
diff --git a/vendor/github.com/Microsoft/go-winio/pkg/guid/guid_nonwindows.go b/vendor/github.com/Microsoft/go-winio/pkg/guid/guid_nonwindows.go
new file mode 100644
index 0000000..805bd35
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/pkg/guid/guid_nonwindows.go
@@ -0,0 +1,16 @@
+//go:build !windows
+// +build !windows
+
+package guid
+
+// GUID represents a GUID/UUID. It has the same structure as
+// golang.org/x/sys/windows.GUID so that it can be used with functions expecting
+// that type. It is defined as its own type as that is only available to builds
+// targeted at `windows`. The representation matches that used by native Windows
+// code.
+type GUID struct {
+ Data1 uint32
+ Data2 uint16
+ Data3 uint16
+ Data4 [8]byte
+}
diff --git a/vendor/github.com/Microsoft/go-winio/pkg/guid/guid_windows.go b/vendor/github.com/Microsoft/go-winio/pkg/guid/guid_windows.go
new file mode 100644
index 0000000..27e45ee
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/pkg/guid/guid_windows.go
@@ -0,0 +1,13 @@
+//go:build windows
+// +build windows
+
+package guid
+
+import "golang.org/x/sys/windows"
+
+// GUID represents a GUID/UUID. It has the same structure as
+// golang.org/x/sys/windows.GUID so that it can be used with functions expecting
+// that type. It is defined as its own type so that stringification and
+// marshaling can be supported. The representation matches that used by native
+// Windows code.
+type GUID windows.GUID
diff --git a/vendor/github.com/Microsoft/go-winio/pkg/guid/variant_string.go b/vendor/github.com/Microsoft/go-winio/pkg/guid/variant_string.go
new file mode 100644
index 0000000..4076d31
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/pkg/guid/variant_string.go
@@ -0,0 +1,27 @@
+// Code generated by "stringer -type=Variant -trimprefix=Variant -linecomment"; DO NOT EDIT.
+
+package guid
+
+import "strconv"
+
+func _() {
+ // An "invalid array index" compiler error signifies that the constant values have changed.
+ // Re-run the stringer command to generate them again.
+ var x [1]struct{}
+ _ = x[VariantUnknown-0]
+ _ = x[VariantNCS-1]
+ _ = x[VariantRFC4122-2]
+ _ = x[VariantMicrosoft-3]
+ _ = x[VariantFuture-4]
+}
+
+const _Variant_name = "UnknownNCSRFC 4122MicrosoftFuture"
+
+var _Variant_index = [...]uint8{0, 7, 10, 18, 27, 33}
+
+func (i Variant) String() string {
+ if i >= Variant(len(_Variant_index)-1) {
+ return "Variant(" + strconv.FormatInt(int64(i), 10) + ")"
+ }
+ return _Variant_name[_Variant_index[i]:_Variant_index[i+1]]
+}
diff --git a/vendor/github.com/Microsoft/go-winio/privilege.go b/vendor/github.com/Microsoft/go-winio/privilege.go
new file mode 100644
index 0000000..0ff9dac
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/privilege.go
@@ -0,0 +1,197 @@
+//go:build windows
+// +build windows
+
+package winio
+
+import (
+ "bytes"
+ "encoding/binary"
+ "fmt"
+ "runtime"
+ "sync"
+ "syscall"
+ "unicode/utf16"
+
+ "golang.org/x/sys/windows"
+)
+
+//sys adjustTokenPrivileges(token windows.Token, releaseAll bool, input *byte, outputSize uint32, output *byte, requiredSize *uint32) (success bool, err error) [true] = advapi32.AdjustTokenPrivileges
+//sys impersonateSelf(level uint32) (err error) = advapi32.ImpersonateSelf
+//sys revertToSelf() (err error) = advapi32.RevertToSelf
+//sys openThreadToken(thread syscall.Handle, accessMask uint32, openAsSelf bool, token *windows.Token) (err error) = advapi32.OpenThreadToken
+//sys getCurrentThread() (h syscall.Handle) = GetCurrentThread
+//sys lookupPrivilegeValue(systemName string, name string, luid *uint64) (err error) = advapi32.LookupPrivilegeValueW
+//sys lookupPrivilegeName(systemName string, luid *uint64, buffer *uint16, size *uint32) (err error) = advapi32.LookupPrivilegeNameW
+//sys lookupPrivilegeDisplayName(systemName string, name *uint16, buffer *uint16, size *uint32, languageId *uint32) (err error) = advapi32.LookupPrivilegeDisplayNameW
+
+const (
+ //revive:disable-next-line:var-naming ALL_CAPS
+ SE_PRIVILEGE_ENABLED = windows.SE_PRIVILEGE_ENABLED
+
+ //revive:disable-next-line:var-naming ALL_CAPS
+ ERROR_NOT_ALL_ASSIGNED syscall.Errno = windows.ERROR_NOT_ALL_ASSIGNED
+
+ SeBackupPrivilege = "SeBackupPrivilege"
+ SeRestorePrivilege = "SeRestorePrivilege"
+ SeSecurityPrivilege = "SeSecurityPrivilege"
+)
+
+var (
+ privNames = make(map[string]uint64)
+ privNameMutex sync.Mutex
+)
+
+// PrivilegeError represents an error enabling privileges.
+type PrivilegeError struct {
+ privileges []uint64
+}
+
+func (e *PrivilegeError) Error() string {
+ s := "Could not enable privilege "
+ if len(e.privileges) > 1 {
+ s = "Could not enable privileges "
+ }
+ for i, p := range e.privileges {
+ if i != 0 {
+ s += ", "
+ }
+ s += `"`
+ s += getPrivilegeName(p)
+ s += `"`
+ }
+ return s
+}
+
+// RunWithPrivilege enables a single privilege for a function call.
+func RunWithPrivilege(name string, fn func() error) error {
+ return RunWithPrivileges([]string{name}, fn)
+}
+
+// RunWithPrivileges enables privileges for a function call.
+func RunWithPrivileges(names []string, fn func() error) error {
+ privileges, err := mapPrivileges(names)
+ if err != nil {
+ return err
+ }
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+ token, err := newThreadToken()
+ if err != nil {
+ return err
+ }
+ defer releaseThreadToken(token)
+ err = adjustPrivileges(token, privileges, SE_PRIVILEGE_ENABLED)
+ if err != nil {
+ return err
+ }
+ return fn()
+}
+
+func mapPrivileges(names []string) ([]uint64, error) {
+ privileges := make([]uint64, 0, len(names))
+ privNameMutex.Lock()
+ defer privNameMutex.Unlock()
+ for _, name := range names {
+ p, ok := privNames[name]
+ if !ok {
+ err := lookupPrivilegeValue("", name, &p)
+ if err != nil {
+ return nil, err
+ }
+ privNames[name] = p
+ }
+ privileges = append(privileges, p)
+ }
+ return privileges, nil
+}
+
+// EnableProcessPrivileges enables privileges globally for the process.
+func EnableProcessPrivileges(names []string) error {
+ return enableDisableProcessPrivilege(names, SE_PRIVILEGE_ENABLED)
+}
+
+// DisableProcessPrivileges disables privileges globally for the process.
+func DisableProcessPrivileges(names []string) error {
+ return enableDisableProcessPrivilege(names, 0)
+}
+
+func enableDisableProcessPrivilege(names []string, action uint32) error {
+ privileges, err := mapPrivileges(names)
+ if err != nil {
+ return err
+ }
+
+ p := windows.CurrentProcess()
+ var token windows.Token
+ err = windows.OpenProcessToken(p, windows.TOKEN_ADJUST_PRIVILEGES|windows.TOKEN_QUERY, &token)
+ if err != nil {
+ return err
+ }
+
+ defer token.Close()
+ return adjustPrivileges(token, privileges, action)
+}
+
+func adjustPrivileges(token windows.Token, privileges []uint64, action uint32) error {
+ var b bytes.Buffer
+ _ = binary.Write(&b, binary.LittleEndian, uint32(len(privileges)))
+ for _, p := range privileges {
+ _ = binary.Write(&b, binary.LittleEndian, p)
+ _ = binary.Write(&b, binary.LittleEndian, action)
+ }
+ prevState := make([]byte, b.Len())
+ reqSize := uint32(0)
+ success, err := adjustTokenPrivileges(token, false, &b.Bytes()[0], uint32(len(prevState)), &prevState[0], &reqSize)
+ if !success {
+ return err
+ }
+ if err == ERROR_NOT_ALL_ASSIGNED { //nolint:errorlint // err is Errno
+ return &PrivilegeError{privileges}
+ }
+ return nil
+}
+
+func getPrivilegeName(luid uint64) string {
+ var nameBuffer [256]uint16
+ bufSize := uint32(len(nameBuffer))
+ err := lookupPrivilegeName("", &luid, &nameBuffer[0], &bufSize)
+ if err != nil {
+ return fmt.Sprintf("
", luid)
+ }
+
+ var displayNameBuffer [256]uint16
+ displayBufSize := uint32(len(displayNameBuffer))
+ var langID uint32
+ err = lookupPrivilegeDisplayName("", &nameBuffer[0], &displayNameBuffer[0], &displayBufSize, &langID)
+ if err != nil {
+ return fmt.Sprintf("", string(utf16.Decode(nameBuffer[:bufSize])))
+ }
+
+ return string(utf16.Decode(displayNameBuffer[:displayBufSize]))
+}
+
+func newThreadToken() (windows.Token, error) {
+ err := impersonateSelf(windows.SecurityImpersonation)
+ if err != nil {
+ return 0, err
+ }
+
+ var token windows.Token
+ err = openThreadToken(getCurrentThread(), syscall.TOKEN_ADJUST_PRIVILEGES|syscall.TOKEN_QUERY, false, &token)
+ if err != nil {
+ rerr := revertToSelf()
+ if rerr != nil {
+ panic(rerr)
+ }
+ return 0, err
+ }
+ return token, nil
+}
+
+func releaseThreadToken(h windows.Token) {
+ err := revertToSelf()
+ if err != nil {
+ panic(err)
+ }
+ h.Close()
+}
diff --git a/vendor/github.com/Microsoft/go-winio/reparse.go b/vendor/github.com/Microsoft/go-winio/reparse.go
new file mode 100644
index 0000000..67d1a10
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/reparse.go
@@ -0,0 +1,131 @@
+//go:build windows
+// +build windows
+
+package winio
+
+import (
+ "bytes"
+ "encoding/binary"
+ "fmt"
+ "strings"
+ "unicode/utf16"
+ "unsafe"
+)
+
+const (
+ reparseTagMountPoint = 0xA0000003
+ reparseTagSymlink = 0xA000000C
+)
+
+type reparseDataBuffer struct {
+ ReparseTag uint32
+ ReparseDataLength uint16
+ Reserved uint16
+ SubstituteNameOffset uint16
+ SubstituteNameLength uint16
+ PrintNameOffset uint16
+ PrintNameLength uint16
+}
+
+// ReparsePoint describes a Win32 symlink or mount point.
+type ReparsePoint struct {
+ Target string
+ IsMountPoint bool
+}
+
+// UnsupportedReparsePointError is returned when trying to decode a non-symlink or
+// mount point reparse point.
+type UnsupportedReparsePointError struct {
+ Tag uint32
+}
+
+func (e *UnsupportedReparsePointError) Error() string {
+ return fmt.Sprintf("unsupported reparse point %x", e.Tag)
+}
+
+// DecodeReparsePoint decodes a Win32 REPARSE_DATA_BUFFER structure containing either a symlink
+// or a mount point.
+func DecodeReparsePoint(b []byte) (*ReparsePoint, error) {
+ tag := binary.LittleEndian.Uint32(b[0:4])
+ return DecodeReparsePointData(tag, b[8:])
+}
+
+func DecodeReparsePointData(tag uint32, b []byte) (*ReparsePoint, error) {
+ isMountPoint := false
+ switch tag {
+ case reparseTagMountPoint:
+ isMountPoint = true
+ case reparseTagSymlink:
+ default:
+ return nil, &UnsupportedReparsePointError{tag}
+ }
+ nameOffset := 8 + binary.LittleEndian.Uint16(b[4:6])
+ if !isMountPoint {
+ nameOffset += 4
+ }
+ nameLength := binary.LittleEndian.Uint16(b[6:8])
+ name := make([]uint16, nameLength/2)
+ err := binary.Read(bytes.NewReader(b[nameOffset:nameOffset+nameLength]), binary.LittleEndian, &name)
+ if err != nil {
+ return nil, err
+ }
+ return &ReparsePoint{string(utf16.Decode(name)), isMountPoint}, nil
+}
+
+func isDriveLetter(c byte) bool {
+ return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
+}
+
+// EncodeReparsePoint encodes a Win32 REPARSE_DATA_BUFFER structure describing a symlink or
+// mount point.
+func EncodeReparsePoint(rp *ReparsePoint) []byte {
+ // Generate an NT path and determine if this is a relative path.
+ var ntTarget string
+ relative := false
+ if strings.HasPrefix(rp.Target, `\\?\`) {
+ ntTarget = `\??\` + rp.Target[4:]
+ } else if strings.HasPrefix(rp.Target, `\\`) {
+ ntTarget = `\??\UNC\` + rp.Target[2:]
+ } else if len(rp.Target) >= 2 && isDriveLetter(rp.Target[0]) && rp.Target[1] == ':' {
+ ntTarget = `\??\` + rp.Target
+ } else {
+ ntTarget = rp.Target
+ relative = true
+ }
+
+ // The paths must be NUL-terminated even though they are counted strings.
+ target16 := utf16.Encode([]rune(rp.Target + "\x00"))
+ ntTarget16 := utf16.Encode([]rune(ntTarget + "\x00"))
+
+ size := int(unsafe.Sizeof(reparseDataBuffer{})) - 8
+ size += len(ntTarget16)*2 + len(target16)*2
+
+ tag := uint32(reparseTagMountPoint)
+ if !rp.IsMountPoint {
+ tag = reparseTagSymlink
+ size += 4 // Add room for symlink flags
+ }
+
+ data := reparseDataBuffer{
+ ReparseTag: tag,
+ ReparseDataLength: uint16(size),
+ SubstituteNameOffset: 0,
+ SubstituteNameLength: uint16((len(ntTarget16) - 1) * 2),
+ PrintNameOffset: uint16(len(ntTarget16) * 2),
+ PrintNameLength: uint16((len(target16) - 1) * 2),
+ }
+
+ var b bytes.Buffer
+ _ = binary.Write(&b, binary.LittleEndian, &data)
+ if !rp.IsMountPoint {
+ flags := uint32(0)
+ if relative {
+ flags |= 1
+ }
+ _ = binary.Write(&b, binary.LittleEndian, flags)
+ }
+
+ _ = binary.Write(&b, binary.LittleEndian, ntTarget16)
+ _ = binary.Write(&b, binary.LittleEndian, target16)
+ return b.Bytes()
+}
diff --git a/vendor/github.com/Microsoft/go-winio/sd.go b/vendor/github.com/Microsoft/go-winio/sd.go
new file mode 100644
index 0000000..5550ef6
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/sd.go
@@ -0,0 +1,144 @@
+//go:build windows
+// +build windows
+
+package winio
+
+import (
+ "errors"
+ "syscall"
+ "unsafe"
+
+ "golang.org/x/sys/windows"
+)
+
+//sys lookupAccountName(systemName *uint16, accountName string, sid *byte, sidSize *uint32, refDomain *uint16, refDomainSize *uint32, sidNameUse *uint32) (err error) = advapi32.LookupAccountNameW
+//sys lookupAccountSid(systemName *uint16, sid *byte, name *uint16, nameSize *uint32, refDomain *uint16, refDomainSize *uint32, sidNameUse *uint32) (err error) = advapi32.LookupAccountSidW
+//sys convertSidToStringSid(sid *byte, str **uint16) (err error) = advapi32.ConvertSidToStringSidW
+//sys convertStringSidToSid(str *uint16, sid **byte) (err error) = advapi32.ConvertStringSidToSidW
+//sys convertStringSecurityDescriptorToSecurityDescriptor(str string, revision uint32, sd *uintptr, size *uint32) (err error) = advapi32.ConvertStringSecurityDescriptorToSecurityDescriptorW
+//sys convertSecurityDescriptorToStringSecurityDescriptor(sd *byte, revision uint32, secInfo uint32, sddl **uint16, sddlSize *uint32) (err error) = advapi32.ConvertSecurityDescriptorToStringSecurityDescriptorW
+//sys localFree(mem uintptr) = LocalFree
+//sys getSecurityDescriptorLength(sd uintptr) (len uint32) = advapi32.GetSecurityDescriptorLength
+
+type AccountLookupError struct {
+ Name string
+ Err error
+}
+
+func (e *AccountLookupError) Error() string {
+ if e.Name == "" {
+ return "lookup account: empty account name specified"
+ }
+ var s string
+ switch {
+ case errors.Is(e.Err, windows.ERROR_INVALID_SID):
+ s = "the security ID structure is invalid"
+ case errors.Is(e.Err, windows.ERROR_NONE_MAPPED):
+ s = "not found"
+ default:
+ s = e.Err.Error()
+ }
+ return "lookup account " + e.Name + ": " + s
+}
+
+func (e *AccountLookupError) Unwrap() error { return e.Err }
+
+type SddlConversionError struct {
+ Sddl string
+ Err error
+}
+
+func (e *SddlConversionError) Error() string {
+ return "convert " + e.Sddl + ": " + e.Err.Error()
+}
+
+func (e *SddlConversionError) Unwrap() error { return e.Err }
+
+// LookupSidByName looks up the SID of an account by name
+//
+//revive:disable-next-line:var-naming SID, not Sid
+func LookupSidByName(name string) (sid string, err error) {
+ if name == "" {
+ return "", &AccountLookupError{name, windows.ERROR_NONE_MAPPED}
+ }
+
+ var sidSize, sidNameUse, refDomainSize uint32
+ err = lookupAccountName(nil, name, nil, &sidSize, nil, &refDomainSize, &sidNameUse)
+ if err != nil && err != syscall.ERROR_INSUFFICIENT_BUFFER { //nolint:errorlint // err is Errno
+ return "", &AccountLookupError{name, err}
+ }
+ sidBuffer := make([]byte, sidSize)
+ refDomainBuffer := make([]uint16, refDomainSize)
+ err = lookupAccountName(nil, name, &sidBuffer[0], &sidSize, &refDomainBuffer[0], &refDomainSize, &sidNameUse)
+ if err != nil {
+ return "", &AccountLookupError{name, err}
+ }
+ var strBuffer *uint16
+ err = convertSidToStringSid(&sidBuffer[0], &strBuffer)
+ if err != nil {
+ return "", &AccountLookupError{name, err}
+ }
+ sid = syscall.UTF16ToString((*[0xffff]uint16)(unsafe.Pointer(strBuffer))[:])
+ localFree(uintptr(unsafe.Pointer(strBuffer)))
+ return sid, nil
+}
+
+// LookupNameBySid looks up the name of an account by SID
+//
+//revive:disable-next-line:var-naming SID, not Sid
+func LookupNameBySid(sid string) (name string, err error) {
+ if sid == "" {
+ return "", &AccountLookupError{sid, windows.ERROR_NONE_MAPPED}
+ }
+
+ sidBuffer, err := windows.UTF16PtrFromString(sid)
+ if err != nil {
+ return "", &AccountLookupError{sid, err}
+ }
+
+ var sidPtr *byte
+ if err = convertStringSidToSid(sidBuffer, &sidPtr); err != nil {
+ return "", &AccountLookupError{sid, err}
+ }
+ defer localFree(uintptr(unsafe.Pointer(sidPtr)))
+
+ var nameSize, refDomainSize, sidNameUse uint32
+ err = lookupAccountSid(nil, sidPtr, nil, &nameSize, nil, &refDomainSize, &sidNameUse)
+ if err != nil && err != windows.ERROR_INSUFFICIENT_BUFFER { //nolint:errorlint // err is Errno
+ return "", &AccountLookupError{sid, err}
+ }
+
+ nameBuffer := make([]uint16, nameSize)
+ refDomainBuffer := make([]uint16, refDomainSize)
+ err = lookupAccountSid(nil, sidPtr, &nameBuffer[0], &nameSize, &refDomainBuffer[0], &refDomainSize, &sidNameUse)
+ if err != nil {
+ return "", &AccountLookupError{sid, err}
+ }
+
+ name = windows.UTF16ToString(nameBuffer)
+ return name, nil
+}
+
+func SddlToSecurityDescriptor(sddl string) ([]byte, error) {
+ var sdBuffer uintptr
+ err := convertStringSecurityDescriptorToSecurityDescriptor(sddl, 1, &sdBuffer, nil)
+ if err != nil {
+ return nil, &SddlConversionError{sddl, err}
+ }
+ defer localFree(sdBuffer)
+ sd := make([]byte, getSecurityDescriptorLength(sdBuffer))
+ copy(sd, (*[0xffff]byte)(unsafe.Pointer(sdBuffer))[:len(sd)])
+ return sd, nil
+}
+
+func SecurityDescriptorToSddl(sd []byte) (string, error) {
+ var sddl *uint16
+ // The returned string length seems to include an arbitrary number of terminating NULs.
+ // Don't use it.
+ err := convertSecurityDescriptorToStringSecurityDescriptor(&sd[0], 1, 0xff, &sddl, nil)
+ if err != nil {
+ return "", err
+ }
+ defer localFree(uintptr(unsafe.Pointer(sddl)))
+ return syscall.UTF16ToString((*[0xffff]uint16)(unsafe.Pointer(sddl))[:]), nil
+}
diff --git a/vendor/github.com/Microsoft/go-winio/syscall.go b/vendor/github.com/Microsoft/go-winio/syscall.go
new file mode 100644
index 0000000..a6ca111
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/syscall.go
@@ -0,0 +1,5 @@
+//go:build windows
+
+package winio
+
+//go:generate go run github.com/Microsoft/go-winio/tools/mkwinsyscall -output zsyscall_windows.go ./*.go
diff --git a/vendor/github.com/Microsoft/go-winio/tools.go b/vendor/github.com/Microsoft/go-winio/tools.go
new file mode 100644
index 0000000..2aa0458
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/tools.go
@@ -0,0 +1,5 @@
+//go:build tools
+
+package winio
+
+import _ "golang.org/x/tools/cmd/stringer"
diff --git a/vendor/github.com/Microsoft/go-winio/zsyscall_windows.go b/vendor/github.com/Microsoft/go-winio/zsyscall_windows.go
new file mode 100644
index 0000000..469b16f
--- /dev/null
+++ b/vendor/github.com/Microsoft/go-winio/zsyscall_windows.go
@@ -0,0 +1,419 @@
+//go:build windows
+
+// Code generated by 'go generate' using "github.com/Microsoft/go-winio/tools/mkwinsyscall"; DO NOT EDIT.
+
+package winio
+
+import (
+ "syscall"
+ "unsafe"
+
+ "golang.org/x/sys/windows"
+)
+
+var _ unsafe.Pointer
+
+// Do the interface allocations only once for common
+// Errno values.
+const (
+ errnoERROR_IO_PENDING = 997
+)
+
+var (
+ errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)
+ errERROR_EINVAL error = syscall.EINVAL
+)
+
+// errnoErr returns common boxed Errno values, to prevent
+// allocations at runtime.
+func errnoErr(e syscall.Errno) error {
+ switch e {
+ case 0:
+ return errERROR_EINVAL
+ case errnoERROR_IO_PENDING:
+ return errERROR_IO_PENDING
+ }
+ // TODO: add more here, after collecting data on the common
+ // error values see on Windows. (perhaps when running
+ // all.bat?)
+ return e
+}
+
+var (
+ modadvapi32 = windows.NewLazySystemDLL("advapi32.dll")
+ modkernel32 = windows.NewLazySystemDLL("kernel32.dll")
+ modntdll = windows.NewLazySystemDLL("ntdll.dll")
+ modws2_32 = windows.NewLazySystemDLL("ws2_32.dll")
+
+ procAdjustTokenPrivileges = modadvapi32.NewProc("AdjustTokenPrivileges")
+ procConvertSecurityDescriptorToStringSecurityDescriptorW = modadvapi32.NewProc("ConvertSecurityDescriptorToStringSecurityDescriptorW")
+ procConvertSidToStringSidW = modadvapi32.NewProc("ConvertSidToStringSidW")
+ procConvertStringSecurityDescriptorToSecurityDescriptorW = modadvapi32.NewProc("ConvertStringSecurityDescriptorToSecurityDescriptorW")
+ procConvertStringSidToSidW = modadvapi32.NewProc("ConvertStringSidToSidW")
+ procGetSecurityDescriptorLength = modadvapi32.NewProc("GetSecurityDescriptorLength")
+ procImpersonateSelf = modadvapi32.NewProc("ImpersonateSelf")
+ procLookupAccountNameW = modadvapi32.NewProc("LookupAccountNameW")
+ procLookupAccountSidW = modadvapi32.NewProc("LookupAccountSidW")
+ procLookupPrivilegeDisplayNameW = modadvapi32.NewProc("LookupPrivilegeDisplayNameW")
+ procLookupPrivilegeNameW = modadvapi32.NewProc("LookupPrivilegeNameW")
+ procLookupPrivilegeValueW = modadvapi32.NewProc("LookupPrivilegeValueW")
+ procOpenThreadToken = modadvapi32.NewProc("OpenThreadToken")
+ procRevertToSelf = modadvapi32.NewProc("RevertToSelf")
+ procBackupRead = modkernel32.NewProc("BackupRead")
+ procBackupWrite = modkernel32.NewProc("BackupWrite")
+ procCancelIoEx = modkernel32.NewProc("CancelIoEx")
+ procConnectNamedPipe = modkernel32.NewProc("ConnectNamedPipe")
+ procCreateIoCompletionPort = modkernel32.NewProc("CreateIoCompletionPort")
+ procCreateNamedPipeW = modkernel32.NewProc("CreateNamedPipeW")
+ procGetCurrentThread = modkernel32.NewProc("GetCurrentThread")
+ procGetNamedPipeHandleStateW = modkernel32.NewProc("GetNamedPipeHandleStateW")
+ procGetNamedPipeInfo = modkernel32.NewProc("GetNamedPipeInfo")
+ procGetQueuedCompletionStatus = modkernel32.NewProc("GetQueuedCompletionStatus")
+ procLocalAlloc = modkernel32.NewProc("LocalAlloc")
+ procLocalFree = modkernel32.NewProc("LocalFree")
+ procSetFileCompletionNotificationModes = modkernel32.NewProc("SetFileCompletionNotificationModes")
+ procNtCreateNamedPipeFile = modntdll.NewProc("NtCreateNamedPipeFile")
+ procRtlDefaultNpAcl = modntdll.NewProc("RtlDefaultNpAcl")
+ procRtlDosPathNameToNtPathName_U = modntdll.NewProc("RtlDosPathNameToNtPathName_U")
+ procRtlNtStatusToDosErrorNoTeb = modntdll.NewProc("RtlNtStatusToDosErrorNoTeb")
+ procWSAGetOverlappedResult = modws2_32.NewProc("WSAGetOverlappedResult")
+)
+
+func adjustTokenPrivileges(token windows.Token, releaseAll bool, input *byte, outputSize uint32, output *byte, requiredSize *uint32) (success bool, err error) {
+ var _p0 uint32
+ if releaseAll {
+ _p0 = 1
+ }
+ r0, _, e1 := syscall.Syscall6(procAdjustTokenPrivileges.Addr(), 6, uintptr(token), uintptr(_p0), uintptr(unsafe.Pointer(input)), uintptr(outputSize), uintptr(unsafe.Pointer(output)), uintptr(unsafe.Pointer(requiredSize)))
+ success = r0 != 0
+ if true {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func convertSecurityDescriptorToStringSecurityDescriptor(sd *byte, revision uint32, secInfo uint32, sddl **uint16, sddlSize *uint32) (err error) {
+ r1, _, e1 := syscall.Syscall6(procConvertSecurityDescriptorToStringSecurityDescriptorW.Addr(), 5, uintptr(unsafe.Pointer(sd)), uintptr(revision), uintptr(secInfo), uintptr(unsafe.Pointer(sddl)), uintptr(unsafe.Pointer(sddlSize)), 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func convertSidToStringSid(sid *byte, str **uint16) (err error) {
+ r1, _, e1 := syscall.Syscall(procConvertSidToStringSidW.Addr(), 2, uintptr(unsafe.Pointer(sid)), uintptr(unsafe.Pointer(str)), 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func convertStringSecurityDescriptorToSecurityDescriptor(str string, revision uint32, sd *uintptr, size *uint32) (err error) {
+ var _p0 *uint16
+ _p0, err = syscall.UTF16PtrFromString(str)
+ if err != nil {
+ return
+ }
+ return _convertStringSecurityDescriptorToSecurityDescriptor(_p0, revision, sd, size)
+}
+
+func _convertStringSecurityDescriptorToSecurityDescriptor(str *uint16, revision uint32, sd *uintptr, size *uint32) (err error) {
+ r1, _, e1 := syscall.Syscall6(procConvertStringSecurityDescriptorToSecurityDescriptorW.Addr(), 4, uintptr(unsafe.Pointer(str)), uintptr(revision), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(size)), 0, 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func convertStringSidToSid(str *uint16, sid **byte) (err error) {
+ r1, _, e1 := syscall.Syscall(procConvertStringSidToSidW.Addr(), 2, uintptr(unsafe.Pointer(str)), uintptr(unsafe.Pointer(sid)), 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func getSecurityDescriptorLength(sd uintptr) (len uint32) {
+ r0, _, _ := syscall.Syscall(procGetSecurityDescriptorLength.Addr(), 1, uintptr(sd), 0, 0)
+ len = uint32(r0)
+ return
+}
+
+func impersonateSelf(level uint32) (err error) {
+ r1, _, e1 := syscall.Syscall(procImpersonateSelf.Addr(), 1, uintptr(level), 0, 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func lookupAccountName(systemName *uint16, accountName string, sid *byte, sidSize *uint32, refDomain *uint16, refDomainSize *uint32, sidNameUse *uint32) (err error) {
+ var _p0 *uint16
+ _p0, err = syscall.UTF16PtrFromString(accountName)
+ if err != nil {
+ return
+ }
+ return _lookupAccountName(systemName, _p0, sid, sidSize, refDomain, refDomainSize, sidNameUse)
+}
+
+func _lookupAccountName(systemName *uint16, accountName *uint16, sid *byte, sidSize *uint32, refDomain *uint16, refDomainSize *uint32, sidNameUse *uint32) (err error) {
+ r1, _, e1 := syscall.Syscall9(procLookupAccountNameW.Addr(), 7, uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(accountName)), uintptr(unsafe.Pointer(sid)), uintptr(unsafe.Pointer(sidSize)), uintptr(unsafe.Pointer(refDomain)), uintptr(unsafe.Pointer(refDomainSize)), uintptr(unsafe.Pointer(sidNameUse)), 0, 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func lookupAccountSid(systemName *uint16, sid *byte, name *uint16, nameSize *uint32, refDomain *uint16, refDomainSize *uint32, sidNameUse *uint32) (err error) {
+ r1, _, e1 := syscall.Syscall9(procLookupAccountSidW.Addr(), 7, uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(sid)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(nameSize)), uintptr(unsafe.Pointer(refDomain)), uintptr(unsafe.Pointer(refDomainSize)), uintptr(unsafe.Pointer(sidNameUse)), 0, 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func lookupPrivilegeDisplayName(systemName string, name *uint16, buffer *uint16, size *uint32, languageId *uint32) (err error) {
+ var _p0 *uint16
+ _p0, err = syscall.UTF16PtrFromString(systemName)
+ if err != nil {
+ return
+ }
+ return _lookupPrivilegeDisplayName(_p0, name, buffer, size, languageId)
+}
+
+func _lookupPrivilegeDisplayName(systemName *uint16, name *uint16, buffer *uint16, size *uint32, languageId *uint32) (err error) {
+ r1, _, e1 := syscall.Syscall6(procLookupPrivilegeDisplayNameW.Addr(), 5, uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(buffer)), uintptr(unsafe.Pointer(size)), uintptr(unsafe.Pointer(languageId)), 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func lookupPrivilegeName(systemName string, luid *uint64, buffer *uint16, size *uint32) (err error) {
+ var _p0 *uint16
+ _p0, err = syscall.UTF16PtrFromString(systemName)
+ if err != nil {
+ return
+ }
+ return _lookupPrivilegeName(_p0, luid, buffer, size)
+}
+
+func _lookupPrivilegeName(systemName *uint16, luid *uint64, buffer *uint16, size *uint32) (err error) {
+ r1, _, e1 := syscall.Syscall6(procLookupPrivilegeNameW.Addr(), 4, uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(luid)), uintptr(unsafe.Pointer(buffer)), uintptr(unsafe.Pointer(size)), 0, 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func lookupPrivilegeValue(systemName string, name string, luid *uint64) (err error) {
+ var _p0 *uint16
+ _p0, err = syscall.UTF16PtrFromString(systemName)
+ if err != nil {
+ return
+ }
+ var _p1 *uint16
+ _p1, err = syscall.UTF16PtrFromString(name)
+ if err != nil {
+ return
+ }
+ return _lookupPrivilegeValue(_p0, _p1, luid)
+}
+
+func _lookupPrivilegeValue(systemName *uint16, name *uint16, luid *uint64) (err error) {
+ r1, _, e1 := syscall.Syscall(procLookupPrivilegeValueW.Addr(), 3, uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(luid)))
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func openThreadToken(thread syscall.Handle, accessMask uint32, openAsSelf bool, token *windows.Token) (err error) {
+ var _p0 uint32
+ if openAsSelf {
+ _p0 = 1
+ }
+ r1, _, e1 := syscall.Syscall6(procOpenThreadToken.Addr(), 4, uintptr(thread), uintptr(accessMask), uintptr(_p0), uintptr(unsafe.Pointer(token)), 0, 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func revertToSelf() (err error) {
+ r1, _, e1 := syscall.Syscall(procRevertToSelf.Addr(), 0, 0, 0, 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func backupRead(h syscall.Handle, b []byte, bytesRead *uint32, abort bool, processSecurity bool, context *uintptr) (err error) {
+ var _p0 *byte
+ if len(b) > 0 {
+ _p0 = &b[0]
+ }
+ var _p1 uint32
+ if abort {
+ _p1 = 1
+ }
+ var _p2 uint32
+ if processSecurity {
+ _p2 = 1
+ }
+ r1, _, e1 := syscall.Syscall9(procBackupRead.Addr(), 7, uintptr(h), uintptr(unsafe.Pointer(_p0)), uintptr(len(b)), uintptr(unsafe.Pointer(bytesRead)), uintptr(_p1), uintptr(_p2), uintptr(unsafe.Pointer(context)), 0, 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func backupWrite(h syscall.Handle, b []byte, bytesWritten *uint32, abort bool, processSecurity bool, context *uintptr) (err error) {
+ var _p0 *byte
+ if len(b) > 0 {
+ _p0 = &b[0]
+ }
+ var _p1 uint32
+ if abort {
+ _p1 = 1
+ }
+ var _p2 uint32
+ if processSecurity {
+ _p2 = 1
+ }
+ r1, _, e1 := syscall.Syscall9(procBackupWrite.Addr(), 7, uintptr(h), uintptr(unsafe.Pointer(_p0)), uintptr(len(b)), uintptr(unsafe.Pointer(bytesWritten)), uintptr(_p1), uintptr(_p2), uintptr(unsafe.Pointer(context)), 0, 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func cancelIoEx(file syscall.Handle, o *syscall.Overlapped) (err error) {
+ r1, _, e1 := syscall.Syscall(procCancelIoEx.Addr(), 2, uintptr(file), uintptr(unsafe.Pointer(o)), 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func connectNamedPipe(pipe syscall.Handle, o *syscall.Overlapped) (err error) {
+ r1, _, e1 := syscall.Syscall(procConnectNamedPipe.Addr(), 2, uintptr(pipe), uintptr(unsafe.Pointer(o)), 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func createIoCompletionPort(file syscall.Handle, port syscall.Handle, key uintptr, threadCount uint32) (newport syscall.Handle, err error) {
+ r0, _, e1 := syscall.Syscall6(procCreateIoCompletionPort.Addr(), 4, uintptr(file), uintptr(port), uintptr(key), uintptr(threadCount), 0, 0)
+ newport = syscall.Handle(r0)
+ if newport == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func createNamedPipe(name string, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *syscall.SecurityAttributes) (handle syscall.Handle, err error) {
+ var _p0 *uint16
+ _p0, err = syscall.UTF16PtrFromString(name)
+ if err != nil {
+ return
+ }
+ return _createNamedPipe(_p0, flags, pipeMode, maxInstances, outSize, inSize, defaultTimeout, sa)
+}
+
+func _createNamedPipe(name *uint16, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *syscall.SecurityAttributes) (handle syscall.Handle, err error) {
+ r0, _, e1 := syscall.Syscall9(procCreateNamedPipeW.Addr(), 8, uintptr(unsafe.Pointer(name)), uintptr(flags), uintptr(pipeMode), uintptr(maxInstances), uintptr(outSize), uintptr(inSize), uintptr(defaultTimeout), uintptr(unsafe.Pointer(sa)), 0)
+ handle = syscall.Handle(r0)
+ if handle == syscall.InvalidHandle {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func getCurrentThread() (h syscall.Handle) {
+ r0, _, _ := syscall.Syscall(procGetCurrentThread.Addr(), 0, 0, 0, 0)
+ h = syscall.Handle(r0)
+ return
+}
+
+func getNamedPipeHandleState(pipe syscall.Handle, state *uint32, curInstances *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32, userName *uint16, maxUserNameSize uint32) (err error) {
+ r1, _, e1 := syscall.Syscall9(procGetNamedPipeHandleStateW.Addr(), 7, uintptr(pipe), uintptr(unsafe.Pointer(state)), uintptr(unsafe.Pointer(curInstances)), uintptr(unsafe.Pointer(maxCollectionCount)), uintptr(unsafe.Pointer(collectDataTimeout)), uintptr(unsafe.Pointer(userName)), uintptr(maxUserNameSize), 0, 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func getNamedPipeInfo(pipe syscall.Handle, flags *uint32, outSize *uint32, inSize *uint32, maxInstances *uint32) (err error) {
+ r1, _, e1 := syscall.Syscall6(procGetNamedPipeInfo.Addr(), 5, uintptr(pipe), uintptr(unsafe.Pointer(flags)), uintptr(unsafe.Pointer(outSize)), uintptr(unsafe.Pointer(inSize)), uintptr(unsafe.Pointer(maxInstances)), 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func getQueuedCompletionStatus(port syscall.Handle, bytes *uint32, key *uintptr, o **ioOperation, timeout uint32) (err error) {
+ r1, _, e1 := syscall.Syscall6(procGetQueuedCompletionStatus.Addr(), 5, uintptr(port), uintptr(unsafe.Pointer(bytes)), uintptr(unsafe.Pointer(key)), uintptr(unsafe.Pointer(o)), uintptr(timeout), 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func localAlloc(uFlags uint32, length uint32) (ptr uintptr) {
+ r0, _, _ := syscall.Syscall(procLocalAlloc.Addr(), 2, uintptr(uFlags), uintptr(length), 0)
+ ptr = uintptr(r0)
+ return
+}
+
+func localFree(mem uintptr) {
+ syscall.Syscall(procLocalFree.Addr(), 1, uintptr(mem), 0, 0)
+ return
+}
+
+func setFileCompletionNotificationModes(h syscall.Handle, flags uint8) (err error) {
+ r1, _, e1 := syscall.Syscall(procSetFileCompletionNotificationModes.Addr(), 2, uintptr(h), uintptr(flags), 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func ntCreateNamedPipeFile(pipe *syscall.Handle, access uint32, oa *objectAttributes, iosb *ioStatusBlock, share uint32, disposition uint32, options uint32, typ uint32, readMode uint32, completionMode uint32, maxInstances uint32, inboundQuota uint32, outputQuota uint32, timeout *int64) (status ntStatus) {
+ r0, _, _ := syscall.Syscall15(procNtCreateNamedPipeFile.Addr(), 14, uintptr(unsafe.Pointer(pipe)), uintptr(access), uintptr(unsafe.Pointer(oa)), uintptr(unsafe.Pointer(iosb)), uintptr(share), uintptr(disposition), uintptr(options), uintptr(typ), uintptr(readMode), uintptr(completionMode), uintptr(maxInstances), uintptr(inboundQuota), uintptr(outputQuota), uintptr(unsafe.Pointer(timeout)), 0)
+ status = ntStatus(r0)
+ return
+}
+
+func rtlDefaultNpAcl(dacl *uintptr) (status ntStatus) {
+ r0, _, _ := syscall.Syscall(procRtlDefaultNpAcl.Addr(), 1, uintptr(unsafe.Pointer(dacl)), 0, 0)
+ status = ntStatus(r0)
+ return
+}
+
+func rtlDosPathNameToNtPathName(name *uint16, ntName *unicodeString, filePart uintptr, reserved uintptr) (status ntStatus) {
+ r0, _, _ := syscall.Syscall6(procRtlDosPathNameToNtPathName_U.Addr(), 4, uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(ntName)), uintptr(filePart), uintptr(reserved), 0, 0)
+ status = ntStatus(r0)
+ return
+}
+
+func rtlNtStatusToDosError(status ntStatus) (winerr error) {
+ r0, _, _ := syscall.Syscall(procRtlNtStatusToDosErrorNoTeb.Addr(), 1, uintptr(status), 0, 0)
+ if r0 != 0 {
+ winerr = syscall.Errno(r0)
+ }
+ return
+}
+
+func wsaGetOverlappedResult(h syscall.Handle, o *syscall.Overlapped, bytes *uint32, wait bool, flags *uint32) (err error) {
+ var _p0 uint32
+ if wait {
+ _p0 = 1
+ }
+ r1, _, e1 := syscall.Syscall6(procWSAGetOverlappedResult.Addr(), 5, uintptr(h), uintptr(unsafe.Pointer(o)), uintptr(unsafe.Pointer(bytes)), uintptr(_p0), uintptr(unsafe.Pointer(flags)), 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
diff --git a/vendor/github.com/ajg/form/.travis.yml b/vendor/github.com/ajg/form/.travis.yml
new file mode 100644
index 0000000..14608c7
--- /dev/null
+++ b/vendor/github.com/ajg/form/.travis.yml
@@ -0,0 +1,25 @@
+## Copyright 2014 Alvaro J. Genial. All rights reserved.
+## Use of this source code is governed by a BSD-style
+## license that can be found in the LICENSE file.
+
+language: go
+
+go:
+ - tip
+ - 1.6
+ - 1.5
+ - 1.4
+ - 1.3
+ # 1.2
+
+before_install:
+ # - go get -v golang.org/x/tools/cmd/cover
+ # - go get -v golang.org/x/tools/cmd/vet
+ # - go get -v golang.org/x/lint/golint
+ - export PATH=$PATH:/home/travis/gopath/bin
+
+script:
+ - go build -v ./...
+ - go test -v -cover ./...
+ - go vet ./...
+ # - golint .
diff --git a/vendor/github.com/ajg/form/LICENSE b/vendor/github.com/ajg/form/LICENSE
new file mode 100644
index 0000000..9190b16
--- /dev/null
+++ b/vendor/github.com/ajg/form/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2014 Alvaro J. Genial. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+ * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/ajg/form/README.md b/vendor/github.com/ajg/form/README.md
new file mode 100644
index 0000000..ad99be4
--- /dev/null
+++ b/vendor/github.com/ajg/form/README.md
@@ -0,0 +1,247 @@
+form
+====
+
+A Form Encoding & Decoding Package for Go, written by [Alvaro J. Genial](http://alva.ro).
+
+[](https://travis-ci.org/ajg/form)
+[](https://godoc.org/github.com/ajg/form)
+
+Synopsis
+--------
+
+This library is designed to allow seamless, high-fidelity encoding and decoding of arbitrary data in `application/x-www-form-urlencoded` format and as [`url.Values`](http://golang.org/pkg/net/url/#Values). It is intended to be useful primarily in dealing with web forms and URI query strings, both of which natively employ said format.
+
+Unsurprisingly, `form` is modeled after other Go [`encoding`](http://golang.org/pkg/encoding/) packages, in particular [`encoding/json`](http://golang.org/pkg/encoding/json/), and follows the same conventions (see below for more.) It aims to automatically handle any kind of concrete Go [data value](#values) (i.e., not functions, channels, etc.) while providing mechanisms for custom behavior.
+
+Status
+------
+
+The implementation is in usable shape and is fairly well tested with its accompanying test suite. The API is unlikely to change much, but still may. Lastly, the code has not yet undergone a security review to ensure it is free of vulnerabilities. Please file an issue or send a pull request for fixes & improvements.
+
+Dependencies
+------------
+
+The only requirement is [Go 1.2](http://golang.org/doc/go1.2) or later.
+
+Usage
+-----
+
+```go
+import "github.com/ajg/form"
+// or: "gopkg.in/ajg/form.v1"
+```
+
+Given a type like the following...
+
+```go
+type User struct {
+ Name string `form:"name"`
+ Email string `form:"email"`
+ Joined time.Time `form:"joined,omitempty"`
+ Posts []int `form:"posts"`
+ Preferences map[string]string `form:"prefs"`
+ Avatar []byte `form:"avatar"`
+ PasswordHash int64 `form:"-"`
+}
+```
+
+...it is easy to encode data of that type...
+
+
+```go
+func PostUser(url string, u User) error {
+ var c http.Client
+ _, err := c.PostForm(url, form.EncodeToValues(u))
+ return err
+}
+```
+
+...as well as decode it...
+
+
+```go
+func Handler(w http.ResponseWriter, r *http.Request) {
+ var u User
+
+ d := form.NewDecoder(r.Body)
+ if err := d.Decode(&u); err != nil {
+ http.Error(w, "Form could not be decoded", http.StatusBadRequest)
+ return
+ }
+
+ fmt.Fprintf(w, "Decoded: %#v", u)
+}
+```
+
+...without having to do any grunt work.
+
+Field Tags
+----------
+
+Like other encoding packages, `form` supports the following options for fields:
+
+ - `` `form:"-"` ``: Causes the field to be ignored during encoding and decoding.
+ - `` `form:""` ``: Overrides the field's name; useful especially when dealing with external identifiers in camelCase, as are commonly found on the web.
+ - `` `form:",omitempty"` ``: Elides the field during encoding if it is empty (typically meaning equal to the type's zero value.)
+ - `` `form:",omitempty"` ``: The way to combine the two options above.
+
+Values
+------
+
+### Simple Values
+
+Values of the following types are all considered simple:
+
+ - `bool`
+ - `int`, `int8`, `int16`, `int32`, `int64`, `rune`
+ - `uint`, `uint8`, `uint16`, `uint32`, `uint64`, `byte`
+ - `float32`, `float64`
+ - `complex64`, `complex128`
+ - `string`
+ - `[]byte` (see note)
+ - [`time.Time`](http://golang.org/pkg/time/#Time)
+ - [`url.URL`](http://golang.org/pkg/net/url/#URL)
+ - An alias of any of the above
+ - A pointer to any of the above
+
+### Composite Values
+
+A composite value is one that can contain other values. Values of the following kinds...
+
+ - Maps
+ - Slices; except `[]byte` (see note)
+ - Structs; except [`time.Time`](http://golang.org/pkg/time/#Time) and [`url.URL`](http://golang.org/pkg/net/url/#URL)
+ - Arrays
+ - An alias of any of the above
+ - A pointer to any of the above
+
+...are considered composites in general, unless they implement custom marshaling/unmarshaling. Composite values are encoded as a flat mapping of paths to values, where the paths are constructed by joining the parent and child paths with a period (`.`).
+
+(Note: a byte slice is treated as a `string` by default because it's more efficient, but can also be decoded as a slice—i.e., with indexes.)
+
+### Untyped Values
+
+While encouraged, it is not necessary to define a type (e.g. a `struct`) in order to use `form`, since it is able to encode and decode untyped data generically using the following rules:
+
+ - Simple values will be treated as a `string`.
+ - Composite values will be treated as a `map[string]interface{}`, itself able to contain nested values (both scalar and compound) ad infinitum.
+ - However, if there is a value (of any supported type) already present in a map for a given key, then it will be used when possible, rather than being replaced with a generic value as specified above; this makes it possible to handle partially typed, dynamic or schema-less values.
+
+### Zero Values
+
+By default, and without custom marshaling, zero values (also known as empty/default values) are encoded as the empty string. To disable this behavior, meaning to keep zero values in their literal form (e.g. `0` for integral types), `Encoder` offers a `KeepZeros` setter method, which will do just that when set to `true`.
+
+### Unsupported Values
+
+Values of the following kinds aren't supported and, if present, must be ignored.
+
+ - Channel
+ - Function
+ - Unsafe pointer
+ - An alias of any of the above
+ - A pointer to any of the above
+
+Custom Marshaling
+-----------------
+
+There is a default (generally lossless) marshaling & unmarshaling scheme for any concrete data value in Go, which is good enough in most cases. However, it is possible to override it and use a custom scheme. For instance, a "binary" field could be marshaled more efficiently using [base64](http://golang.org/pkg/encoding/base64/) to prevent it from being percent-escaped during serialization to `application/x-www-form-urlencoded` format.
+
+Because `form` provides support for [`encoding.TextMarshaler`](http://golang.org/pkg/encoding/#TextMarshaler) and [`encoding.TextUnmarshaler`](http://golang.org/pkg/encoding/#TextUnmarshaler) it is easy to do that; for instance, like this:
+
+```go
+import "encoding"
+
+type Binary []byte
+
+var (
+ _ encoding.TextMarshaler = &Binary{}
+ _ encoding.TextUnmarshaler = &Binary{}
+)
+
+func (b Binary) MarshalText() ([]byte, error) {
+ return []byte(base64.URLEncoding.EncodeToString([]byte(b))), nil
+}
+
+func (b *Binary) UnmarshalText(text []byte) error {
+ bs, err := base64.URLEncoding.DecodeString(string(text))
+ if err == nil {
+ *b = Binary(bs)
+ }
+ return err
+}
+```
+
+Now any value with type `Binary` will automatically be encoded using the [URL](http://golang.org/pkg/encoding/base64/#URLEncoding) variant of base64. It is left as an exercise to the reader to improve upon this scheme by eliminating the need for padding (which, besides being superfluous, uses `=`, a character that will end up percent-escaped.)
+
+Keys
+----
+
+In theory any value can be a key as long as it has a string representation. However, by default, periods have special meaning to `form`, and thus, under the hood (i.e. in encoded form) they are transparently escaped using a preceding backslash (`\`). Backslashes within keys, themselves, are also escaped in this manner (e.g. as `\\`) in order to permit representing `\.` itself (as `\\\.`).
+
+(Note: it is normally unnecessary to deal with this issue unless keys are being constructed manually—e.g. literally embedded in HTML or in a URI.)
+
+The default delimiter and escape characters used for encoding and decoding composite keys can be changed using the `DelimitWith` and `EscapeWith` setter methods of `Encoder` and `Decoder`, respectively. For example...
+
+```go
+package main
+
+import (
+ "os"
+
+ "github.com/ajg/form"
+)
+
+func main() {
+ type B struct {
+ Qux string `form:"qux"`
+ }
+ type A struct {
+ FooBar B `form:"foo.bar"`
+ }
+ a := A{FooBar: B{"XYZ"}}
+ os.Stdout.WriteString("Default: ")
+ form.NewEncoder(os.Stdout).Encode(a)
+ os.Stdout.WriteString("\nCustom: ")
+ form.NewEncoder(os.Stdout).DelimitWith('/').Encode(a)
+ os.Stdout.WriteString("\n")
+}
+
+```
+
+...will produce...
+
+```
+Default: foo%5C.bar.qux=XYZ
+Custom: foo.bar%2Fqux=XYZ
+```
+
+(`%5C` and `%2F` represent `\` and `/`, respectively.)
+
+Limitations
+-----------
+
+ - Circular (self-referential) values are untested.
+
+Future Work
+-----------
+
+The following items would be nice to have in the future—though they are not being worked on yet:
+
+ - An option to treat all values as if they had been tagged with `omitempty`.
+ - An option to automatically treat all field names in `camelCase` or `underscore_case`.
+ - Built-in support for the types in [`math/big`](http://golang.org/pkg/math/big/).
+ - Built-in support for the types in [`image/color`](http://golang.org/pkg/image/color/).
+ - Improve encoding/decoding by reading/writing directly from/to the `io.Reader`/`io.Writer` when possible, rather than going through an intermediate representation (i.e. `node`) which requires more memory.
+
+(Feel free to implement any of these and then send a pull request.)
+
+Related Work
+------------
+
+ - Package [gorilla/schema](https://github.com/gorilla/schema), which only implements decoding.
+ - Package [google/go-querystring](https://github.com/google/go-querystring), which only implements encoding.
+
+License
+-------
+
+This library is distributed under a BSD-style [LICENSE](./LICENSE).
diff --git a/vendor/github.com/ajg/form/TODO.md b/vendor/github.com/ajg/form/TODO.md
new file mode 100644
index 0000000..d344727
--- /dev/null
+++ b/vendor/github.com/ajg/form/TODO.md
@@ -0,0 +1,4 @@
+TODO
+====
+
+ - Document IgnoreCase and IgnoreUnknownKeys in README.
diff --git a/vendor/github.com/ajg/form/decode.go b/vendor/github.com/ajg/form/decode.go
new file mode 100644
index 0000000..dd8bd4f
--- /dev/null
+++ b/vendor/github.com/ajg/form/decode.go
@@ -0,0 +1,370 @@
+// Copyright 2014 Alvaro J. Genial. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package form
+
+import (
+ "fmt"
+ "io"
+ "io/ioutil"
+ "net/url"
+ "reflect"
+ "strconv"
+ "time"
+)
+
+// NewDecoder returns a new form Decoder.
+func NewDecoder(r io.Reader) *Decoder {
+ return &Decoder{r, defaultDelimiter, defaultEscape, false, false}
+}
+
+// Decoder decodes data from a form (application/x-www-form-urlencoded).
+type Decoder struct {
+ r io.Reader
+ d rune
+ e rune
+ ignoreUnknown bool
+ ignoreCase bool
+}
+
+// DelimitWith sets r as the delimiter used for composite keys by Decoder d and returns the latter; it is '.' by default.
+func (d *Decoder) DelimitWith(r rune) *Decoder {
+ d.d = r
+ return d
+}
+
+// EscapeWith sets r as the escape used for delimiters (and to escape itself) by Decoder d and returns the latter; it is '\\' by default.
+func (d *Decoder) EscapeWith(r rune) *Decoder {
+ d.e = r
+ return d
+}
+
+// Decode reads in and decodes form-encoded data into dst.
+func (d Decoder) Decode(dst interface{}) error {
+ bs, err := ioutil.ReadAll(d.r)
+ if err != nil {
+ return err
+ }
+ vs, err := url.ParseQuery(string(bs))
+ if err != nil {
+ return err
+ }
+ v := reflect.ValueOf(dst)
+ return d.decodeNode(v, parseValues(d.d, d.e, vs, canIndexOrdinally(v)))
+}
+
+// IgnoreUnknownKeys if set to true it will make the Decoder ignore values
+// that are not found in the destination object instead of returning an error.
+func (d *Decoder) IgnoreUnknownKeys(ignoreUnknown bool) {
+ d.ignoreUnknown = ignoreUnknown
+}
+
+// IgnoreCase if set to true it will make the Decoder try to set values in the
+// destination object even if the case does not match.
+func (d *Decoder) IgnoreCase(ignoreCase bool) {
+ d.ignoreCase = ignoreCase
+}
+
+// DecodeString decodes src into dst.
+func (d Decoder) DecodeString(dst interface{}, src string) error {
+ vs, err := url.ParseQuery(src)
+ if err != nil {
+ return err
+ }
+ v := reflect.ValueOf(dst)
+ return d.decodeNode(v, parseValues(d.d, d.e, vs, canIndexOrdinally(v)))
+}
+
+// DecodeValues decodes vs into dst.
+func (d Decoder) DecodeValues(dst interface{}, vs url.Values) error {
+ v := reflect.ValueOf(dst)
+ return d.decodeNode(v, parseValues(d.d, d.e, vs, canIndexOrdinally(v)))
+}
+
+// DecodeString decodes src into dst.
+func DecodeString(dst interface{}, src string) error {
+ return NewDecoder(nil).DecodeString(dst, src)
+}
+
+// DecodeValues decodes vs into dst.
+func DecodeValues(dst interface{}, vs url.Values) error {
+ return NewDecoder(nil).DecodeValues(dst, vs)
+}
+
+func (d Decoder) decodeNode(v reflect.Value, n node) (err error) {
+ defer func() {
+ if e := recover(); e != nil {
+ err = fmt.Errorf("%v", e)
+ }
+ }()
+
+ if v.Kind() == reflect.Slice {
+ return fmt.Errorf("could not decode directly into slice; use pointer to slice")
+ }
+ d.decodeValue(v, n)
+ return nil
+}
+
+func (d Decoder) decodeValue(v reflect.Value, x interface{}) {
+ t := v.Type()
+ k := v.Kind()
+
+ if k == reflect.Ptr && v.IsNil() {
+ v.Set(reflect.New(t.Elem()))
+ }
+
+ if unmarshalValue(v, x) {
+ return
+ }
+
+ empty := isEmpty(x)
+
+ switch k {
+ case reflect.Ptr:
+ d.decodeValue(v.Elem(), x)
+ return
+ case reflect.Interface:
+ if !v.IsNil() {
+ d.decodeValue(v.Elem(), x)
+ return
+
+ } else if empty {
+ return // Allow nil interfaces only if empty.
+ } else {
+ panic("form: cannot decode non-empty value into into nil interface")
+ }
+ }
+
+ if empty {
+ v.Set(reflect.Zero(t)) // Treat the empty string as the zero value.
+ return
+ }
+
+ switch k {
+ case reflect.Struct:
+ if t.ConvertibleTo(timeType) {
+ d.decodeTime(v, x)
+ } else if t.ConvertibleTo(urlType) {
+ d.decodeURL(v, x)
+ } else {
+ d.decodeStruct(v, x)
+ }
+ case reflect.Slice:
+ d.decodeSlice(v, x)
+ case reflect.Array:
+ d.decodeArray(v, x)
+ case reflect.Map:
+ d.decodeMap(v, x)
+ case reflect.Invalid, reflect.Uintptr, reflect.UnsafePointer, reflect.Chan, reflect.Func:
+ panic(t.String() + " has unsupported kind " + k.String())
+ default:
+ d.decodeBasic(v, x)
+ }
+}
+
+func (d Decoder) decodeStruct(v reflect.Value, x interface{}) {
+ t := v.Type()
+ for k, c := range getNode(x) {
+ if f, ok := findField(v, k, d.ignoreCase); !ok && k == "" {
+ panic(getString(x) + " cannot be decoded as " + t.String())
+ } else if !ok {
+ if !d.ignoreUnknown {
+ panic(k + " doesn't exist in " + t.String())
+ }
+ } else if !f.CanSet() {
+ panic(k + " cannot be set in " + t.String())
+ } else {
+ d.decodeValue(f, c)
+ }
+ }
+}
+
+func (d Decoder) decodeMap(v reflect.Value, x interface{}) {
+ t := v.Type()
+ if v.IsNil() {
+ v.Set(reflect.MakeMap(t))
+ }
+ for k, c := range getNode(x) {
+ i := reflect.New(t.Key()).Elem()
+ d.decodeValue(i, k)
+
+ w := v.MapIndex(i)
+ if w.IsValid() { // We have an actual element value to decode into.
+ if w.Kind() == reflect.Interface {
+ w = w.Elem()
+ }
+ w = reflect.New(w.Type()).Elem()
+ } else if t.Elem().Kind() != reflect.Interface { // The map's element type is concrete.
+ w = reflect.New(t.Elem()).Elem()
+ } else {
+ // The best we can do here is to decode as either a string (for scalars) or a map[string]interface {} (for the rest).
+ // We could try to guess the type based on the string (e.g. true/false => bool) but that'll get ugly fast,
+ // especially if we have to guess the kind (slice vs. array vs. map) and index type (e.g. string, int, etc.)
+ switch c.(type) {
+ case node:
+ w = reflect.MakeMap(stringMapType)
+ case string:
+ w = reflect.New(stringType).Elem()
+ default:
+ panic("value is neither node nor string")
+ }
+ }
+
+ d.decodeValue(w, c)
+ v.SetMapIndex(i, w)
+ }
+}
+
+func (d Decoder) decodeArray(v reflect.Value, x interface{}) {
+ t := v.Type()
+ for k, c := range getNode(x) {
+ i, err := strconv.Atoi(k)
+ if err != nil {
+ panic(k + " is not a valid index for type " + t.String())
+ }
+ if l := v.Len(); i >= l {
+ panic("index is above array size")
+ }
+ d.decodeValue(v.Index(i), c)
+ }
+}
+
+func (d Decoder) decodeSlice(v reflect.Value, x interface{}) {
+ t := v.Type()
+ if t.Elem().Kind() == reflect.Uint8 {
+ // Allow, but don't require, byte slices to be encoded as a single string.
+ if s, ok := x.(string); ok {
+ v.SetBytes([]byte(s))
+ return
+ }
+ }
+
+ // NOTE: Implicit indexing is currently done at the parseValues level,
+ // so if if an implicitKey reaches here it will always replace the last.
+ implicit := 0
+ for k, c := range getNode(x) {
+ var i int
+ if k == implicitKey {
+ i = implicit
+ implicit++
+ } else {
+ explicit, err := strconv.Atoi(k)
+ if err != nil {
+ panic(k + " is not a valid index for type " + t.String())
+ }
+ i = explicit
+ implicit = explicit + 1
+ }
+ // "Extend" the slice if it's too short.
+ if l := v.Len(); i >= l {
+ delta := i - l + 1
+ v.Set(reflect.AppendSlice(v, reflect.MakeSlice(t, delta, delta)))
+ }
+ d.decodeValue(v.Index(i), c)
+ }
+}
+
+func (d Decoder) decodeBasic(v reflect.Value, x interface{}) {
+ t := v.Type()
+ switch k, s := t.Kind(), getString(x); k {
+ case reflect.Bool:
+ if b, e := strconv.ParseBool(s); e == nil {
+ v.SetBool(b)
+ } else {
+ panic("could not parse bool from " + strconv.Quote(s))
+ }
+ case reflect.Int,
+ reflect.Int8,
+ reflect.Int16,
+ reflect.Int32,
+ reflect.Int64:
+ if i, e := strconv.ParseInt(s, 10, 64); e == nil {
+ v.SetInt(i)
+ } else {
+ panic("could not parse int from " + strconv.Quote(s))
+ }
+ case reflect.Uint,
+ reflect.Uint8,
+ reflect.Uint16,
+ reflect.Uint32,
+ reflect.Uint64:
+ if u, e := strconv.ParseUint(s, 10, 64); e == nil {
+ v.SetUint(u)
+ } else {
+ panic("could not parse uint from " + strconv.Quote(s))
+ }
+ case reflect.Float32,
+ reflect.Float64:
+ if f, e := strconv.ParseFloat(s, 64); e == nil {
+ v.SetFloat(f)
+ } else {
+ panic("could not parse float from " + strconv.Quote(s))
+ }
+ case reflect.Complex64,
+ reflect.Complex128:
+ var c complex128
+ if n, err := fmt.Sscanf(s, "%g", &c); n == 1 && err == nil {
+ v.SetComplex(c)
+ } else {
+ panic("could not parse complex from " + strconv.Quote(s))
+ }
+ case reflect.String:
+ v.SetString(s)
+ default:
+ panic(t.String() + " has unsupported kind " + k.String())
+ }
+}
+
+func (d Decoder) decodeTime(v reflect.Value, x interface{}) {
+ t := v.Type()
+ s := getString(x)
+ // TODO: Find a more efficient way to do this.
+ for _, f := range allowedTimeFormats {
+ if p, err := time.Parse(f, s); err == nil {
+ v.Set(reflect.ValueOf(p).Convert(v.Type()))
+ return
+ }
+ }
+ panic("cannot decode string `" + s + "` as " + t.String())
+}
+
+func (d Decoder) decodeURL(v reflect.Value, x interface{}) {
+ t := v.Type()
+ s := getString(x)
+ if u, err := url.Parse(s); err == nil {
+ v.Set(reflect.ValueOf(*u).Convert(v.Type()))
+ return
+ }
+ panic("cannot decode string `" + s + "` as " + t.String())
+}
+
+var allowedTimeFormats = []string{
+ "2006-01-02T15:04:05.999999999Z07:00",
+ "2006-01-02T15:04:05.999999999Z07",
+ "2006-01-02T15:04:05.999999999Z",
+ "2006-01-02T15:04:05.999999999",
+ "2006-01-02T15:04:05Z07:00",
+ "2006-01-02T15:04:05Z07",
+ "2006-01-02T15:04:05Z",
+ "2006-01-02T15:04:05",
+ "2006-01-02T15:04Z",
+ "2006-01-02T15:04",
+ "2006-01-02T15Z",
+ "2006-01-02T15",
+ "2006-01-02",
+ "2006-01",
+ "2006",
+ "15:04:05.999999999Z07:00",
+ "15:04:05.999999999Z07",
+ "15:04:05.999999999Z",
+ "15:04:05.999999999",
+ "15:04:05Z07:00",
+ "15:04:05Z07",
+ "15:04:05Z",
+ "15:04:05",
+ "15:04Z",
+ "15:04",
+ "15Z",
+ "15",
+}
diff --git a/vendor/github.com/ajg/form/encode.go b/vendor/github.com/ajg/form/encode.go
new file mode 100644
index 0000000..57a0d0a
--- /dev/null
+++ b/vendor/github.com/ajg/form/encode.go
@@ -0,0 +1,388 @@
+// Copyright 2014 Alvaro J. Genial. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package form
+
+import (
+ "encoding"
+ "errors"
+ "fmt"
+ "io"
+ "net/url"
+ "reflect"
+ "strconv"
+ "strings"
+ "time"
+)
+
+// NewEncoder returns a new form Encoder.
+func NewEncoder(w io.Writer) *Encoder {
+ return &Encoder{w, defaultDelimiter, defaultEscape, false}
+}
+
+// Encoder provides a way to encode to a Writer.
+type Encoder struct {
+ w io.Writer
+ d rune
+ e rune
+ z bool
+}
+
+// DelimitWith sets r as the delimiter used for composite keys by Encoder e and returns the latter; it is '.' by default.
+func (e *Encoder) DelimitWith(r rune) *Encoder {
+ e.d = r
+ return e
+}
+
+// EscapeWith sets r as the escape used for delimiters (and to escape itself) by Encoder e and returns the latter; it is '\\' by default.
+func (e *Encoder) EscapeWith(r rune) *Encoder {
+ e.e = r
+ return e
+}
+
+// KeepZeros sets whether Encoder e should keep zero (default) values in their literal form when encoding, and returns the former; by default zero values are not kept, but are rather encoded as the empty string.
+func (e *Encoder) KeepZeros(z bool) *Encoder {
+ e.z = z
+ return e
+}
+
+// Encode encodes dst as form and writes it out using the Encoder's Writer.
+func (e Encoder) Encode(dst interface{}) error {
+ v := reflect.ValueOf(dst)
+ n, err := encodeToNode(v, e.z)
+ if err != nil {
+ return err
+ }
+ s := n.values(e.d, e.e).Encode()
+ l, err := io.WriteString(e.w, s)
+ switch {
+ case err != nil:
+ return err
+ case l != len(s):
+ return errors.New("could not write data completely")
+ }
+ return nil
+}
+
+// EncodeToString encodes dst as a form and returns it as a string.
+func EncodeToString(dst interface{}) (string, error) {
+ v := reflect.ValueOf(dst)
+ n, err := encodeToNode(v, false)
+ if err != nil {
+ return "", err
+ }
+ vs := n.values(defaultDelimiter, defaultEscape)
+ return vs.Encode(), nil
+}
+
+// EncodeToValues encodes dst as a form and returns it as Values.
+func EncodeToValues(dst interface{}) (url.Values, error) {
+ v := reflect.ValueOf(dst)
+ n, err := encodeToNode(v, false)
+ if err != nil {
+ return nil, err
+ }
+ vs := n.values(defaultDelimiter, defaultEscape)
+ return vs, nil
+}
+
+func encodeToNode(v reflect.Value, z bool) (n node, err error) {
+ defer func() {
+ if e := recover(); e != nil {
+ err = fmt.Errorf("%v", e)
+ }
+ }()
+ return getNode(encodeValue(v, z)), nil
+}
+
+func encodeValue(v reflect.Value, z bool) interface{} {
+ t := v.Type()
+ k := v.Kind()
+
+ if s, ok := marshalValue(v); ok {
+ return s
+ } else if !z && isEmptyValue(v) {
+ return "" // Treat the zero value as the empty string.
+ }
+
+ switch k {
+ case reflect.Ptr, reflect.Interface:
+ return encodeValue(v.Elem(), z)
+ case reflect.Struct:
+ if t.ConvertibleTo(timeType) {
+ return encodeTime(v)
+ } else if t.ConvertibleTo(urlType) {
+ return encodeURL(v)
+ }
+ return encodeStruct(v, z)
+ case reflect.Slice:
+ return encodeSlice(v, z)
+ case reflect.Array:
+ return encodeArray(v, z)
+ case reflect.Map:
+ return encodeMap(v, z)
+ case reflect.Invalid, reflect.Uintptr, reflect.UnsafePointer, reflect.Chan, reflect.Func:
+ panic(t.String() + " has unsupported kind " + t.Kind().String())
+ default:
+ return encodeBasic(v)
+ }
+}
+
+func encodeStruct(v reflect.Value, z bool) interface{} {
+ t := v.Type()
+ n := node{}
+ for i := 0; i < t.NumField(); i++ {
+ f := t.Field(i)
+ k, oe := fieldInfo(f)
+
+ if k == "-" {
+ continue
+ } else if fv := v.Field(i); oe && isEmptyValue(fv) {
+ delete(n, k)
+ } else {
+ n[k] = encodeValue(fv, z)
+ }
+ }
+ return n
+}
+
+func encodeMap(v reflect.Value, z bool) interface{} {
+ n := node{}
+ for _, i := range v.MapKeys() {
+ k := getString(encodeValue(i, z))
+ n[k] = encodeValue(v.MapIndex(i), z)
+ }
+ return n
+}
+
+func encodeArray(v reflect.Value, z bool) interface{} {
+ n := node{}
+ for i := 0; i < v.Len(); i++ {
+ n[strconv.Itoa(i)] = encodeValue(v.Index(i), z)
+ }
+ return n
+}
+
+func encodeSlice(v reflect.Value, z bool) interface{} {
+ t := v.Type()
+ if t.Elem().Kind() == reflect.Uint8 {
+ return string(v.Bytes()) // Encode byte slices as a single string by default.
+ }
+ n := node{}
+ for i := 0; i < v.Len(); i++ {
+ n[strconv.Itoa(i)] = encodeValue(v.Index(i), z)
+ }
+ return n
+}
+
+func encodeTime(v reflect.Value) string {
+ t := v.Convert(timeType).Interface().(time.Time)
+ if t.Year() == 0 && (t.Month() == 0 || t.Month() == 1) && (t.Day() == 0 || t.Day() == 1) {
+ return t.Format("15:04:05.999999999Z07:00")
+ } else if t.Hour() == 0 && t.Minute() == 0 && t.Second() == 0 && t.Nanosecond() == 0 {
+ return t.Format("2006-01-02")
+ }
+ return t.Format("2006-01-02T15:04:05.999999999Z07:00")
+}
+
+func encodeURL(v reflect.Value) string {
+ u := v.Convert(urlType).Interface().(url.URL)
+ return u.String()
+}
+
+func encodeBasic(v reflect.Value) string {
+ t := v.Type()
+ switch k := t.Kind(); k {
+ case reflect.Bool:
+ return strconv.FormatBool(v.Bool())
+ case reflect.Int,
+ reflect.Int8,
+ reflect.Int16,
+ reflect.Int32,
+ reflect.Int64:
+ return strconv.FormatInt(v.Int(), 10)
+ case reflect.Uint,
+ reflect.Uint8,
+ reflect.Uint16,
+ reflect.Uint32,
+ reflect.Uint64:
+ return strconv.FormatUint(v.Uint(), 10)
+ case reflect.Float32:
+ return strconv.FormatFloat(v.Float(), 'g', -1, 32)
+ case reflect.Float64:
+ return strconv.FormatFloat(v.Float(), 'g', -1, 64)
+ case reflect.Complex64, reflect.Complex128:
+ s := fmt.Sprintf("%g", v.Complex())
+ return strings.TrimSuffix(strings.TrimPrefix(s, "("), ")")
+ case reflect.String:
+ return v.String()
+ }
+ panic(t.String() + " has unsupported kind " + t.Kind().String())
+}
+
+func isEmptyValue(v reflect.Value) bool {
+ switch t := v.Type(); v.Kind() {
+ case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
+ return v.Len() == 0
+ case reflect.Bool:
+ return !v.Bool()
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return v.Int() == 0
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return v.Uint() == 0
+ case reflect.Float32, reflect.Float64:
+ return v.Float() == 0
+ case reflect.Complex64, reflect.Complex128:
+ return v.Complex() == 0
+ case reflect.Interface, reflect.Ptr:
+ return v.IsNil()
+ case reflect.Struct:
+ if t.ConvertibleTo(timeType) {
+ return v.Convert(timeType).Interface().(time.Time).IsZero()
+ }
+ return reflect.DeepEqual(v, reflect.Zero(t))
+ }
+ return false
+}
+
+// canIndexOrdinally returns whether a value contains an ordered sequence of elements.
+func canIndexOrdinally(v reflect.Value) bool {
+ if !v.IsValid() {
+ return false
+ }
+ switch t := v.Type(); t.Kind() {
+ case reflect.Ptr, reflect.Interface:
+ return canIndexOrdinally(v.Elem())
+ case reflect.Slice, reflect.Array:
+ return true
+ }
+ return false
+}
+
+func fieldInfo(f reflect.StructField) (k string, oe bool) {
+ if f.PkgPath != "" { // Skip private fields.
+ return omittedKey, oe
+ }
+
+ k = f.Name
+ tag := f.Tag.Get("form")
+ if tag == "" {
+ return k, oe
+ }
+
+ ps := strings.SplitN(tag, ",", 2)
+ if ps[0] != "" {
+ k = ps[0]
+ }
+ if len(ps) == 2 {
+ oe = ps[1] == "omitempty"
+ }
+ return k, oe
+}
+
+func findField(v reflect.Value, n string, ignoreCase bool) (reflect.Value, bool) {
+ t := v.Type()
+ l := v.NumField()
+
+ var lowerN string
+ caseInsensitiveMatch := -1
+ if ignoreCase {
+ lowerN = strings.ToLower(n)
+ }
+
+ // First try named fields.
+ for i := 0; i < l; i++ {
+ f := t.Field(i)
+ k, _ := fieldInfo(f)
+ if k == omittedKey {
+ continue
+ } else if n == k {
+ return v.Field(i), true
+ } else if ignoreCase && lowerN == strings.ToLower(k) {
+ caseInsensitiveMatch = i
+ }
+ }
+
+ // If no exact match was found try case insensitive match.
+ if caseInsensitiveMatch != -1 {
+ return v.Field(caseInsensitiveMatch), true
+ }
+
+ // Then try anonymous (embedded) fields.
+ for i := 0; i < l; i++ {
+ f := t.Field(i)
+ k, _ := fieldInfo(f)
+ if k == omittedKey || !f.Anonymous { // || k != "" ?
+ continue
+ }
+ fv := v.Field(i)
+ fk := fv.Kind()
+ for fk == reflect.Ptr || fk == reflect.Interface {
+ fv = fv.Elem()
+ fk = fv.Kind()
+ }
+
+ if fk != reflect.Struct {
+ continue
+ }
+ if ev, ok := findField(fv, n, ignoreCase); ok {
+ return ev, true
+ }
+ }
+
+ return reflect.Value{}, false
+}
+
+var (
+ stringType = reflect.TypeOf(string(""))
+ stringMapType = reflect.TypeOf(map[string]interface{}{})
+ timeType = reflect.TypeOf(time.Time{})
+ timePtrType = reflect.TypeOf(&time.Time{})
+ urlType = reflect.TypeOf(url.URL{})
+)
+
+func skipTextMarshalling(t reflect.Type) bool {
+ /*// Skip time.Time because its text unmarshaling is overly rigid:
+ return t == timeType || t == timePtrType*/
+ // Skip time.Time & convertibles because its text unmarshaling is overly rigid:
+ return t.ConvertibleTo(timeType) || t.ConvertibleTo(timePtrType)
+}
+
+func unmarshalValue(v reflect.Value, x interface{}) bool {
+ if skipTextMarshalling(v.Type()) {
+ return false
+ }
+
+ tu, ok := v.Interface().(encoding.TextUnmarshaler)
+ if !ok && !v.CanAddr() {
+ return false
+ } else if !ok {
+ return unmarshalValue(v.Addr(), x)
+ }
+
+ s := getString(x)
+ if err := tu.UnmarshalText([]byte(s)); err != nil {
+ panic(err)
+ }
+ return true
+}
+
+func marshalValue(v reflect.Value) (string, bool) {
+ if skipTextMarshalling(v.Type()) {
+ return "", false
+ }
+
+ tm, ok := v.Interface().(encoding.TextMarshaler)
+ if !ok && !v.CanAddr() {
+ return "", false
+ } else if !ok {
+ return marshalValue(v.Addr())
+ }
+
+ bs, err := tm.MarshalText()
+ if err != nil {
+ panic(err)
+ }
+ return string(bs), true
+}
diff --git a/vendor/github.com/ajg/form/form.go b/vendor/github.com/ajg/form/form.go
new file mode 100644
index 0000000..4052369
--- /dev/null
+++ b/vendor/github.com/ajg/form/form.go
@@ -0,0 +1,14 @@
+// Copyright 2014 Alvaro J. Genial. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package form implements encoding and decoding of application/x-www-form-urlencoded data.
+package form
+
+const (
+ implicitKey = "_"
+ omittedKey = "-"
+
+ defaultDelimiter = '.'
+ defaultEscape = '\\'
+)
diff --git a/vendor/github.com/ajg/form/node.go b/vendor/github.com/ajg/form/node.go
new file mode 100644
index 0000000..567aaaf
--- /dev/null
+++ b/vendor/github.com/ajg/form/node.go
@@ -0,0 +1,152 @@
+// Copyright 2014 Alvaro J. Genial. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package form
+
+import (
+ "net/url"
+ "strconv"
+ "strings"
+)
+
+type node map[string]interface{}
+
+func (n node) values(d, e rune) url.Values {
+ vs := url.Values{}
+ n.merge(d, e, "", &vs)
+ return vs
+}
+
+func (n node) merge(d, e rune, p string, vs *url.Values) {
+ for k, x := range n {
+ switch y := x.(type) {
+ case string:
+ vs.Add(p+escape(d, e, k), y)
+ case node:
+ y.merge(d, e, p+escape(d, e, k)+string(d), vs)
+ default:
+ panic("value is neither string nor node")
+ }
+ }
+}
+
+// TODO: Add tests for implicit indexing.
+func parseValues(d, e rune, vs url.Values, canIndexFirstLevelOrdinally bool) node {
+ // NOTE: Because of the flattening of potentially multiple strings to one key, implicit indexing works:
+ // i. At the first level; e.g. Foo.Bar=A&Foo.Bar=B becomes 0.Foo.Bar=A&1.Foo.Bar=B
+ // ii. At the last level; e.g. Foo.Bar._=A&Foo.Bar._=B becomes Foo.Bar.0=A&Foo.Bar.1=B
+ // TODO: At in-between levels; e.g. Foo._.Bar=A&Foo._.Bar=B becomes Foo.0.Bar=A&Foo.1.Bar=B
+ // (This last one requires that there only be one placeholder in order for it to be unambiguous.)
+
+ m := map[string]string{}
+ for k, ss := range vs {
+ indexLastLevelOrdinally := strings.HasSuffix(k, string(d)+implicitKey)
+
+ for i, s := range ss {
+ if canIndexFirstLevelOrdinally {
+ k = strconv.Itoa(i) + string(d) + k
+ } else if indexLastLevelOrdinally {
+ k = strings.TrimSuffix(k, implicitKey) + strconv.Itoa(i)
+ }
+
+ m[k] = s
+ }
+ }
+
+ n := node{}
+ for k, s := range m {
+ n = n.split(d, e, k, s)
+ }
+ return n
+}
+
+func splitPath(d, e rune, path string) (k, rest string) {
+ esc := false
+ for i, r := range path {
+ switch {
+ case !esc && r == e:
+ esc = true
+ case !esc && r == d:
+ return unescape(d, e, path[:i]), path[i+1:]
+ default:
+ esc = false
+ }
+ }
+ return unescape(d, e, path), ""
+}
+
+func (n node) split(d, e rune, path, s string) node {
+ k, rest := splitPath(d, e, path)
+ if rest == "" {
+ return add(n, k, s)
+ }
+ if _, ok := n[k]; !ok {
+ n[k] = node{}
+ }
+
+ c := getNode(n[k])
+ n[k] = c.split(d, e, rest, s)
+ return n
+}
+
+func add(n node, k, s string) node {
+ if n == nil {
+ return node{k: s}
+ }
+
+ if _, ok := n[k]; ok {
+ panic("key " + k + " already set")
+ }
+
+ n[k] = s
+ return n
+}
+
+func isEmpty(x interface{}) bool {
+ switch y := x.(type) {
+ case string:
+ return y == ""
+ case node:
+ if s, ok := y[""].(string); ok {
+ return s == ""
+ }
+ return false
+ }
+ panic("value is neither string nor node")
+}
+
+func getNode(x interface{}) node {
+ switch y := x.(type) {
+ case string:
+ return node{"": y}
+ case node:
+ return y
+ }
+ panic("value is neither string nor node")
+}
+
+func getString(x interface{}) string {
+ switch y := x.(type) {
+ case string:
+ return y
+ case node:
+ if s, ok := y[""].(string); ok {
+ return s
+ }
+ return ""
+ }
+ panic("value is neither string nor node")
+}
+
+func escape(d, e rune, s string) string {
+ s = strings.Replace(s, string(e), string(e)+string(e), -1) // Escape the escape (\ => \\)
+ s = strings.Replace(s, string(d), string(e)+string(d), -1) // Escape the delimiter (. => \.)
+ return s
+}
+
+func unescape(d, e rune, s string) string {
+ s = strings.Replace(s, string(e)+string(d), string(d), -1) // Unescape the delimiter (\. => .)
+ s = strings.Replace(s, string(e)+string(e), string(e), -1) // Unescape the escape (\\ => \)
+ return s
+}
diff --git a/vendor/github.com/ajg/form/pre-commit.sh b/vendor/github.com/ajg/form/pre-commit.sh
new file mode 100644
index 0000000..29ce311
--- /dev/null
+++ b/vendor/github.com/ajg/form/pre-commit.sh
@@ -0,0 +1,18 @@
+#!/bin/bash -eu
+
+# TODO: Only colorize messages given a suitable terminal.
+# FIXME: Handle case in which no stash entry is created due to no changes.
+
+printf "\e[30m=== PRE-COMMIT STARTING ===\e[m\n"
+git stash save --quiet --keep-index --include-untracked
+
+if go build -v ./... && go test -v -cover ./... && go vet ./... && golint . && travis-lint; then
+ result=$?
+ printf "\e[32m=== PRE-COMMIT SUCCEEDED ===\e[m\n"
+else
+ result=$?
+ printf "\e[31m=== PRE-COMMIT FAILED ===\e[m\n"
+fi
+
+git stash pop --quiet
+exit $result
diff --git a/vendor/github.com/chorus-services/backbeat/pkg/sdk/README.md b/vendor/github.com/chorus-services/backbeat/pkg/sdk/README.md
new file mode 100644
index 0000000..2889b2e
--- /dev/null
+++ b/vendor/github.com/chorus-services/backbeat/pkg/sdk/README.md
@@ -0,0 +1,373 @@
+# BACKBEAT Go SDK
+
+The BACKBEAT Go SDK enables CHORUS services to become "BACKBEAT-aware" by providing client libraries for beat synchronization, status emission, and beat-budget management.
+
+## Features
+
+- **Beat Subscription (BACKBEAT-REQ-040)**: Subscribe to beat and downbeat events with jitter-tolerant scheduling
+- **Status Emission (BACKBEAT-REQ-041)**: Emit status claims with automatic agent_id, task_id, and HLC population
+- **Beat Budgets (BACKBEAT-REQ-042)**: Execute functions with beat-based timeouts and cancellation
+- **Legacy Compatibility (BACKBEAT-REQ-043)**: Support for legacy `{bar,beat}` patterns with migration warnings
+- **Security (BACKBEAT-REQ-044)**: Ed25519 signing and required headers for status claims
+- **Local Degradation**: Continue operating when pulse service is unavailable
+- **Comprehensive Observability**: Metrics, health reporting, and performance monitoring
+
+## Quick Start
+
+```go
+package main
+
+import (
+ "context"
+ "crypto/ed25519"
+ "crypto/rand"
+ "log/slog"
+
+ "github.com/chorus-services/backbeat/pkg/sdk"
+)
+
+func main() {
+ // Generate signing key
+ _, signingKey, _ := ed25519.GenerateKey(rand.Reader)
+
+ // Configure SDK
+ config := sdk.DefaultConfig()
+ config.ClusterID = "chorus-dev"
+ config.AgentID = "my-service"
+ config.NATSUrl = "nats://localhost:4222"
+ config.SigningKey = signingKey
+
+ // Create client
+ client := sdk.NewClient(config)
+
+ // Register beat callback
+ client.OnBeat(func(beat sdk.BeatFrame) {
+ slog.Info("Beat received", "beat_index", beat.BeatIndex)
+
+ // Emit status
+ client.EmitStatusClaim(sdk.StatusClaim{
+ State: "executing",
+ BeatsLeft: 5,
+ Progress: 0.3,
+ Notes: "Processing data",
+ })
+ })
+
+ // Start client
+ ctx := context.Background()
+ if err := client.Start(ctx); err != nil {
+ panic(err)
+ }
+ defer client.Stop()
+
+ // Your service logic here...
+ select {}
+}
+```
+
+## Configuration
+
+### Basic Configuration
+
+```go
+config := &sdk.Config{
+ ClusterID: "your-cluster", // BACKBEAT cluster ID
+ AgentID: "your-agent", // Unique agent identifier
+ NATSUrl: "nats://localhost:4222", // NATS connection URL
+}
+```
+
+### Advanced Configuration
+
+```go
+config := sdk.DefaultConfig()
+config.ClusterID = "chorus-prod"
+config.AgentID = "web-service-01"
+config.NATSUrl = "nats://nats.cluster.local:4222"
+config.SigningKey = loadSigningKey() // Ed25519 private key
+config.JitterTolerance = 100 * time.Millisecond
+config.ReconnectDelay = 2 * time.Second
+config.MaxReconnects = 10 // -1 for infinite
+config.Logger = slog.New(slog.NewJSONHandler(os.Stdout, nil))
+```
+
+## Core Features
+
+### Beat Subscription
+
+```go
+// Register beat callback (called every beat)
+client.OnBeat(func(beat sdk.BeatFrame) {
+ // Your beat logic here
+ fmt.Printf("Beat %d at %s\n", beat.BeatIndex, beat.DeadlineAt)
+})
+
+// Register downbeat callback (called at bar starts)
+client.OnDownbeat(func(beat sdk.BeatFrame) {
+ // Your downbeat logic here
+ fmt.Printf("Bar started: %s\n", beat.WindowID)
+})
+```
+
+### Status Emission
+
+```go
+// Basic status emission
+err := client.EmitStatusClaim(sdk.StatusClaim{
+ State: "executing", // executing|planning|waiting|review|done|failed
+ BeatsLeft: 10, // estimated beats remaining
+ Progress: 0.75, // progress ratio (0.0-1.0)
+ Notes: "Processing batch 5/10",
+})
+
+// Advanced status with task tracking
+err := client.EmitStatusClaim(sdk.StatusClaim{
+ TaskID: "task-12345", // auto-generated if empty
+ State: "waiting",
+ WaitFor: []string{"hmmm://thread/abc123"}, // dependencies
+ BeatsLeft: 0,
+ Progress: 1.0,
+ Notes: "Waiting for thread completion",
+})
+```
+
+### Beat Budgets
+
+```go
+// Execute with beat-based timeout
+err := client.WithBeatBudget(10, func() error {
+ // This function has 10 beats to complete
+ return performTask()
+})
+
+if err != nil {
+ // Handle timeout or task error
+ fmt.Printf("Task failed or exceeded budget: %v\n", err)
+}
+
+// Real-world example
+err := client.WithBeatBudget(20, func() error {
+ // Database operation with beat budget
+ ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+ defer cancel()
+
+ return database.ProcessBatch(ctx, batchData)
+})
+```
+
+## Client Interface
+
+```go
+type Client interface {
+ // Beat subscription
+ OnBeat(callback func(BeatFrame)) error
+ OnDownbeat(callback func(BeatFrame)) error
+
+ // Status emission
+ EmitStatusClaim(claim StatusClaim) error
+
+ // Beat budgets
+ WithBeatBudget(n int, fn func() error) error
+
+ // Utilities
+ GetCurrentBeat() int64
+ GetCurrentWindow() string
+ IsInWindow(windowID string) bool
+
+ // Lifecycle
+ Start(ctx context.Context) error
+ Stop() error
+ Health() HealthStatus
+}
+```
+
+## Examples
+
+The SDK includes comprehensive examples:
+
+- **[Simple Agent](examples/simple_agent.go)**: Basic beat subscription and status emission
+- **[Task Processor](examples/task_processor.go)**: Beat budget usage for task timeout management
+- **[Service Monitor](examples/service_monitor.go)**: Health monitoring with beat-aligned reporting
+
+### Running Examples
+
+```bash
+# Simple agent example
+go run pkg/sdk/examples/simple_agent.go
+
+# Task processor with beat budgets
+go run pkg/sdk/examples/task_processor.go
+
+# Service monitor with health reporting
+go run pkg/sdk/examples/service_monitor.go
+```
+
+## Observability
+
+### Health Monitoring
+
+```go
+health := client.Health()
+fmt.Printf("Connected: %v\n", health.Connected)
+fmt.Printf("Last Beat: %d at %s\n", health.LastBeat, health.LastBeatTime)
+fmt.Printf("Time Drift: %s\n", health.TimeDrift)
+fmt.Printf("Reconnects: %d\n", health.ReconnectCount)
+fmt.Printf("Local Degradation: %v\n", health.LocalDegradation)
+```
+
+### Metrics
+
+The SDK exposes metrics via Go's `expvar` package:
+
+- Connection metrics: status, reconnection count, duration
+- Beat metrics: received, jitter, callback latency, misses
+- Status metrics: claims emitted, errors
+- Budget metrics: created, completed, timed out
+- Error metrics: total count, last error
+
+Access metrics at `http://localhost:8080/debug/vars` when using `expvar`.
+
+### Logging
+
+The SDK uses structured logging via `slog`:
+
+```go
+config.Logger = slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
+ Level: slog.LevelDebug, // Set appropriate level
+}))
+```
+
+## Error Handling
+
+The SDK provides comprehensive error handling:
+
+- **Connection Errors**: Automatic reconnection with exponential backoff
+- **Beat Jitter**: Tolerance for network delays and timing variations
+- **Callback Panics**: Recovery and logging without affecting other callbacks
+- **Validation Errors**: Status claim validation with detailed error messages
+- **Timeout Errors**: Beat budget timeouts with context cancellation
+
+## Local Degradation
+
+When the pulse service is unavailable, the SDK automatically enters local degradation mode:
+
+- Generates synthetic beats to maintain callback timing
+- Uses fallback 60 BPM tempo
+- Marks beat frames with "degraded" phase
+- Automatically recovers when pulse service returns
+
+## Legacy Compatibility
+
+Support for legacy `{bar,beat}` patterns (BACKBEAT-REQ-043):
+
+```go
+// Convert legacy format (logs warning once)
+beatIndex := client.ConvertLegacyBeat(bar, beat)
+
+// Get legacy format from current beat
+legacy := client.GetLegacyBeatInfo()
+fmt.Printf("Bar: %d, Beat: %d\n", legacy.Bar, legacy.Beat)
+```
+
+## Security
+
+The SDK implements BACKBEAT security requirements:
+
+- **Ed25519 Signatures**: All status claims are signed when signing key provided
+- **Required Headers**: Includes `x-window-id` and `x-hlc` headers
+- **Agent Identification**: Automatic `x-agent-id` header for routing
+
+```go
+// Configure signing
+_, signingKey, _ := ed25519.GenerateKey(rand.Reader)
+config.SigningKey = signingKey
+```
+
+## Performance
+
+The SDK is designed for high performance:
+
+- **Beat Callback Latency**: Target ≤5ms callback execution
+- **Timer Drift**: ≤1% drift over 1 hour without leader
+- **Concurrent Safe**: All operations are goroutine-safe
+- **Memory Efficient**: Bounded error lists and metric samples
+
+## Integration Patterns
+
+### Web Service Integration
+
+```go
+func main() {
+ // Initialize BACKBEAT client
+ client := sdk.NewClient(config)
+ client.OnBeat(func(beat sdk.BeatFrame) {
+ // Report web service status
+ client.EmitStatusClaim(sdk.StatusClaim{
+ State: "executing",
+ Progress: getRequestSuccessRate(),
+ Notes: fmt.Sprintf("Handling %d req/s", getCurrentRPS()),
+ })
+ })
+
+ // Start HTTP server
+ http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
+ health := client.Health()
+ json.NewEncoder(w).Encode(health)
+ })
+}
+```
+
+### Background Job Processor
+
+```go
+func processJobs(client sdk.Client) {
+ for job := range jobQueue {
+ // Use beat budget for job timeout
+ err := client.WithBeatBudget(job.MaxBeats, func() error {
+ return processJob(job)
+ })
+
+ if err != nil {
+ client.EmitStatusClaim(sdk.StatusClaim{
+ TaskID: job.ID,
+ State: "failed",
+ Notes: err.Error(),
+ })
+ }
+ }
+}
+```
+
+## Testing
+
+The SDK includes comprehensive test utilities:
+
+```bash
+# Run all tests
+go test ./pkg/sdk/...
+
+# Run with race detection
+go test -race ./pkg/sdk/...
+
+# Run benchmarks
+go test -bench=. ./pkg/sdk/examples/
+```
+
+## Requirements
+
+- Go 1.22 or later
+- NATS server for messaging
+- BACKBEAT pulse service running
+- Network connectivity to cluster
+
+## Contributing
+
+1. Follow standard Go conventions
+2. Include comprehensive tests
+3. Update documentation for API changes
+4. Ensure examples remain working
+5. Maintain backward compatibility
+
+## License
+
+This SDK is part of the BACKBEAT project and follows the same licensing terms.
\ No newline at end of file
diff --git a/vendor/github.com/chorus-services/backbeat/pkg/sdk/client.go b/vendor/github.com/chorus-services/backbeat/pkg/sdk/client.go
new file mode 100644
index 0000000..8ce5387
--- /dev/null
+++ b/vendor/github.com/chorus-services/backbeat/pkg/sdk/client.go
@@ -0,0 +1,480 @@
+// Package sdk provides the BACKBEAT Go SDK for enabling CHORUS services
+// to become BACKBEAT-aware with beat synchronization and status emission.
+package sdk
+
+import (
+ "context"
+ "crypto/ed25519"
+ "encoding/json"
+ "fmt"
+ "log/slog"
+ "sync"
+ "time"
+
+ "github.com/google/uuid"
+ "github.com/nats-io/nats.go"
+)
+
+// Client interface defines the core BACKBEAT SDK functionality
+// Implements BACKBEAT-REQ-040, 041, 042, 043, 044
+type Client interface {
+ // Beat subscription (BACKBEAT-REQ-040)
+ OnBeat(callback func(BeatFrame)) error
+ OnDownbeat(callback func(BeatFrame)) error
+
+ // Status emission (BACKBEAT-REQ-041)
+ EmitStatusClaim(claim StatusClaim) error
+
+ // Beat budgets (BACKBEAT-REQ-042)
+ WithBeatBudget(n int, fn func() error) error
+
+ // Utilities
+ GetCurrentBeat() int64
+ GetCurrentWindow() string
+ IsInWindow(windowID string) bool
+ GetCurrentTempo() int
+ GetTempoDrift() time.Duration
+
+ // Lifecycle management
+ Start(ctx context.Context) error
+ Stop() error
+ Health() HealthStatus
+}
+
+// Config represents the SDK configuration
+type Config struct {
+ ClusterID string // BACKBEAT cluster identifier
+ AgentID string // Unique agent identifier
+ NATSUrl string // NATS connection URL
+ SigningKey ed25519.PrivateKey // Ed25519 private key for signing (BACKBEAT-REQ-044)
+ Logger *slog.Logger // Structured logger
+ JitterTolerance time.Duration // Maximum jitter tolerance (default: 50ms)
+ ReconnectDelay time.Duration // NATS reconnection delay (default: 1s)
+ MaxReconnects int // Maximum reconnection attempts (default: -1 for infinite)
+}
+
+// DefaultConfig returns a Config with sensible defaults
+func DefaultConfig() *Config {
+ return &Config{
+ JitterTolerance: 50 * time.Millisecond,
+ ReconnectDelay: 1 * time.Second,
+ MaxReconnects: -1, // Infinite reconnects
+ Logger: slog.Default(),
+ }
+}
+
+// BeatFrame represents a beat frame with timing information
+type BeatFrame struct {
+ Type string `json:"type"`
+ ClusterID string `json:"cluster_id"`
+ BeatIndex int64 `json:"beat_index"`
+ Downbeat bool `json:"downbeat"`
+ Phase string `json:"phase"`
+ HLC string `json:"hlc"`
+ DeadlineAt time.Time `json:"deadline_at"`
+ TempoBPM int `json:"tempo_bpm"`
+ WindowID string `json:"window_id"`
+}
+
+// StatusClaim represents a status claim emission
+type StatusClaim struct {
+ // Auto-populated by SDK
+ Type string `json:"type"` // Always "backbeat.statusclaim.v1"
+ AgentID string `json:"agent_id"` // Auto-populated from config
+ TaskID string `json:"task_id"` // Auto-generated if not provided
+ BeatIndex int64 `json:"beat_index"` // Auto-populated from current beat
+ HLC string `json:"hlc"` // Auto-populated from current HLC
+
+ // User-provided
+ State string `json:"state"` // executing|planning|waiting|review|done|failed
+ WaitFor []string `json:"wait_for,omitempty"` // refs (e.g., hmmm://thread/...)
+ BeatsLeft int `json:"beats_left"` // estimated beats remaining
+ Progress float64 `json:"progress"` // progress ratio (0.0-1.0)
+ Notes string `json:"notes"` // status description
+}
+
+// HealthStatus represents the current health of the SDK client
+type HealthStatus struct {
+ Connected bool `json:"connected"`
+ LastBeat int64 `json:"last_beat"`
+ LastBeatTime time.Time `json:"last_beat_time"`
+ TimeDrift time.Duration `json:"time_drift"`
+ ReconnectCount int `json:"reconnect_count"`
+ LocalDegradation bool `json:"local_degradation"`
+ CurrentTempo int `json:"current_tempo"`
+ TempoDrift time.Duration `json:"tempo_drift"`
+ MeasuredBPM float64 `json:"measured_bpm"`
+ Errors []string `json:"errors,omitempty"`
+}
+
+// LegacyBeatInfo represents legacy {bar,beat} information
+// For BACKBEAT-REQ-043 compatibility
+type LegacyBeatInfo struct {
+ Bar int `json:"bar"`
+ Beat int `json:"beat"`
+}
+
+// tempoSample represents a tempo measurement for drift calculation
+type tempoSample struct {
+ BeatIndex int64
+ Tempo int
+ MeasuredTime time.Time
+ ActualBPM float64 // Measured BPM based on inter-beat timing
+}
+
+// client implements the Client interface
+type client struct {
+ config *Config
+ nc *nats.Conn
+ ctx context.Context
+ cancel context.CancelFunc
+ wg sync.WaitGroup
+
+ // Beat tracking
+ currentBeat int64
+ currentWindow string
+ currentHLC string
+ lastBeatTime time.Time
+ currentTempo int // Current tempo in BPM
+ lastTempo int // Last known tempo for drift calculation
+ tempoHistory []tempoSample // History for drift calculation
+ beatMutex sync.RWMutex
+
+ // Callbacks
+ beatCallbacks []func(BeatFrame)
+ downbeatCallbacks []func(BeatFrame)
+ callbackMutex sync.RWMutex
+
+ // Health and metrics
+ reconnectCount int
+ localDegradation bool
+ errors []string
+ errorMutex sync.RWMutex
+ metrics *Metrics
+
+ // Beat budget tracking
+ budgetContexts map[string]context.CancelFunc
+ budgetMutex sync.Mutex
+
+ // Legacy compatibility
+ legacyWarned bool
+ legacyMutex sync.Mutex
+}
+
+// NewClient creates a new BACKBEAT SDK client
+func NewClient(config *Config) Client {
+ if config.Logger == nil {
+ config.Logger = slog.Default()
+ }
+
+ c := &client{
+ config: config,
+ beatCallbacks: make([]func(BeatFrame), 0),
+ downbeatCallbacks: make([]func(BeatFrame), 0),
+ budgetContexts: make(map[string]context.CancelFunc),
+ errors: make([]string, 0),
+ tempoHistory: make([]tempoSample, 0, 100),
+ currentTempo: 60, // Default to 60 BPM
+ }
+
+ // Initialize metrics
+ prefix := fmt.Sprintf("backbeat.sdk.%s", config.AgentID)
+ c.metrics = NewMetrics(prefix)
+
+ return c
+}
+
+// Start initializes the client and begins beat synchronization
+func (c *client) Start(ctx context.Context) error {
+ c.ctx, c.cancel = context.WithCancel(ctx)
+
+ if err := c.connect(); err != nil {
+ return fmt.Errorf("failed to connect to NATS: %w", err)
+ }
+
+ c.wg.Add(1)
+ go c.beatSubscriptionLoop()
+
+ c.config.Logger.Info("BACKBEAT SDK client started",
+ slog.String("cluster_id", c.config.ClusterID),
+ slog.String("agent_id", c.config.AgentID))
+
+ return nil
+}
+
+// Stop gracefully stops the client
+func (c *client) Stop() error {
+ if c.cancel != nil {
+ c.cancel()
+ }
+
+ // Cancel all active beat budgets
+ c.budgetMutex.Lock()
+ for id, cancel := range c.budgetContexts {
+ cancel()
+ delete(c.budgetContexts, id)
+ }
+ c.budgetMutex.Unlock()
+
+ if c.nc != nil {
+ c.nc.Close()
+ }
+
+ c.wg.Wait()
+
+ c.config.Logger.Info("BACKBEAT SDK client stopped")
+ return nil
+}
+
+// OnBeat registers a callback for beat events (BACKBEAT-REQ-040)
+func (c *client) OnBeat(callback func(BeatFrame)) error {
+ if callback == nil {
+ return fmt.Errorf("callback cannot be nil")
+ }
+
+ c.callbackMutex.Lock()
+ defer c.callbackMutex.Unlock()
+
+ c.beatCallbacks = append(c.beatCallbacks, callback)
+ return nil
+}
+
+// OnDownbeat registers a callback for downbeat events (BACKBEAT-REQ-040)
+func (c *client) OnDownbeat(callback func(BeatFrame)) error {
+ if callback == nil {
+ return fmt.Errorf("callback cannot be nil")
+ }
+
+ c.callbackMutex.Lock()
+ defer c.callbackMutex.Unlock()
+
+ c.downbeatCallbacks = append(c.downbeatCallbacks, callback)
+ return nil
+}
+
+// EmitStatusClaim emits a status claim (BACKBEAT-REQ-041)
+func (c *client) EmitStatusClaim(claim StatusClaim) error {
+ // Auto-populate required fields
+ claim.Type = "backbeat.statusclaim.v1"
+ claim.AgentID = c.config.AgentID
+ claim.BeatIndex = c.GetCurrentBeat()
+ claim.HLC = c.getCurrentHLC()
+
+ // Auto-generate task ID if not provided
+ if claim.TaskID == "" {
+ claim.TaskID = fmt.Sprintf("task:%s", uuid.New().String()[:8])
+ }
+
+ // Validate the claim
+ if err := c.validateStatusClaim(&claim); err != nil {
+ return fmt.Errorf("invalid status claim: %w", err)
+ }
+
+ // Sign the claim if signing key is available (BACKBEAT-REQ-044)
+ if c.config.SigningKey != nil {
+ if err := c.signStatusClaim(&claim); err != nil {
+ return fmt.Errorf("failed to sign status claim: %w", err)
+ }
+ }
+
+ // Publish to NATS
+ data, err := json.Marshal(claim)
+ if err != nil {
+ return fmt.Errorf("failed to marshal status claim: %w", err)
+ }
+
+ subject := fmt.Sprintf("backbeat.status.%s", c.config.ClusterID)
+ headers := c.createHeaders()
+
+ msg := &nats.Msg{
+ Subject: subject,
+ Data: data,
+ Header: headers,
+ }
+
+ if err := c.nc.PublishMsg(msg); err != nil {
+ c.addError(fmt.Sprintf("failed to publish status claim: %v", err))
+ c.metrics.RecordStatusClaim(false)
+ return fmt.Errorf("failed to publish status claim: %w", err)
+ }
+
+ c.metrics.RecordStatusClaim(true)
+ c.config.Logger.Debug("Status claim emitted",
+ slog.String("agent_id", claim.AgentID),
+ slog.String("task_id", claim.TaskID),
+ slog.String("state", claim.State),
+ slog.Int64("beat_index", claim.BeatIndex))
+
+ return nil
+}
+
+// WithBeatBudget executes a function with a beat-based timeout (BACKBEAT-REQ-042)
+func (c *client) WithBeatBudget(n int, fn func() error) error {
+ if n <= 0 {
+ return fmt.Errorf("beat budget must be positive, got %d", n)
+ }
+
+ // Calculate timeout based on current tempo
+ currentBeat := c.GetCurrentBeat()
+ beatDuration := c.getBeatDuration()
+ timeout := time.Duration(n) * beatDuration
+
+ // Use background context if client context is not set (for testing)
+ baseCtx := c.ctx
+ if baseCtx == nil {
+ baseCtx = context.Background()
+ }
+
+ ctx, cancel := context.WithTimeout(baseCtx, timeout)
+ defer cancel()
+
+ // Track the budget context for cancellation
+ budgetID := uuid.New().String()
+ c.budgetMutex.Lock()
+ c.budgetContexts[budgetID] = cancel
+ c.budgetMutex.Unlock()
+
+ // Record budget creation
+ c.metrics.RecordBudgetCreated()
+
+ defer func() {
+ c.budgetMutex.Lock()
+ delete(c.budgetContexts, budgetID)
+ c.budgetMutex.Unlock()
+ }()
+
+ // Execute function with timeout
+ done := make(chan error, 1)
+ go func() {
+ done <- fn()
+ }()
+
+ select {
+ case err := <-done:
+ c.metrics.RecordBudgetCompleted(false) // Not timed out
+ if err != nil {
+ c.config.Logger.Debug("Beat budget function completed with error",
+ slog.Int("budget", n),
+ slog.Int64("start_beat", currentBeat),
+ slog.String("error", err.Error()))
+ } else {
+ c.config.Logger.Debug("Beat budget function completed successfully",
+ slog.Int("budget", n),
+ slog.Int64("start_beat", currentBeat))
+ }
+ return err
+ case <-ctx.Done():
+ c.metrics.RecordBudgetCompleted(true) // Timed out
+ c.config.Logger.Warn("Beat budget exceeded",
+ slog.Int("budget", n),
+ slog.Int64("start_beat", currentBeat),
+ slog.Duration("timeout", timeout))
+ return fmt.Errorf("beat budget of %d beats exceeded", n)
+ }
+}
+
+// GetCurrentBeat returns the current beat index
+func (c *client) GetCurrentBeat() int64 {
+ c.beatMutex.RLock()
+ defer c.beatMutex.RUnlock()
+ return c.currentBeat
+}
+
+// GetCurrentWindow returns the current window ID
+func (c *client) GetCurrentWindow() string {
+ c.beatMutex.RLock()
+ defer c.beatMutex.RUnlock()
+ return c.currentWindow
+}
+
+// IsInWindow checks if we're currently in the specified window
+func (c *client) IsInWindow(windowID string) bool {
+ return c.GetCurrentWindow() == windowID
+}
+
+// GetCurrentTempo returns the current tempo in BPM
+func (c *client) GetCurrentTempo() int {
+ c.beatMutex.RLock()
+ defer c.beatMutex.RUnlock()
+ return c.currentTempo
+}
+
+// GetTempoDrift calculates the drift between expected and actual tempo
+func (c *client) GetTempoDrift() time.Duration {
+ c.beatMutex.RLock()
+ defer c.beatMutex.RUnlock()
+
+ if len(c.tempoHistory) < 2 {
+ return 0
+ }
+
+ // Calculate average measured BPM from recent samples
+ historyLen := len(c.tempoHistory)
+ recentCount := 10
+ if historyLen < recentCount {
+ recentCount = historyLen
+ }
+
+ recent := c.tempoHistory[historyLen-recentCount:]
+ if len(recent) < 2 {
+ recent = c.tempoHistory
+ }
+
+ totalBPM := 0.0
+ for _, sample := range recent {
+ totalBPM += sample.ActualBPM
+ }
+ avgMeasuredBPM := totalBPM / float64(len(recent))
+
+ // Calculate drift
+ expectedBeatDuration := 60.0 / float64(c.currentTempo)
+ actualBeatDuration := 60.0 / avgMeasuredBPM
+
+ drift := actualBeatDuration - expectedBeatDuration
+ return time.Duration(drift * float64(time.Second))
+}
+
+// Health returns the current health status
+func (c *client) Health() HealthStatus {
+ c.errorMutex.RLock()
+ errors := make([]string, len(c.errors))
+ copy(errors, c.errors)
+ c.errorMutex.RUnlock()
+
+ c.beatMutex.RLock()
+ timeDrift := time.Since(c.lastBeatTime)
+ currentTempo := c.currentTempo
+
+ // Calculate measured BPM from recent tempo history
+ measuredBPM := 60.0 // Default
+ if len(c.tempoHistory) > 0 {
+ historyLen := len(c.tempoHistory)
+ recentCount := 5
+ if historyLen < recentCount {
+ recentCount = historyLen
+ }
+
+ recent := c.tempoHistory[historyLen-recentCount:]
+ totalBPM := 0.0
+ for _, sample := range recent {
+ totalBPM += sample.ActualBPM
+ }
+ measuredBPM = totalBPM / float64(len(recent))
+ }
+ c.beatMutex.RUnlock()
+
+ tempoDrift := c.GetTempoDrift()
+
+ return HealthStatus{
+ Connected: c.nc != nil && c.nc.IsConnected(),
+ LastBeat: c.GetCurrentBeat(),
+ LastBeatTime: c.lastBeatTime,
+ TimeDrift: timeDrift,
+ ReconnectCount: c.reconnectCount,
+ LocalDegradation: c.localDegradation,
+ CurrentTempo: currentTempo,
+ TempoDrift: tempoDrift,
+ MeasuredBPM: measuredBPM,
+ Errors: errors,
+ }
+}
\ No newline at end of file
diff --git a/vendor/github.com/chorus-services/backbeat/pkg/sdk/doc.go b/vendor/github.com/chorus-services/backbeat/pkg/sdk/doc.go
new file mode 100644
index 0000000..c949c78
--- /dev/null
+++ b/vendor/github.com/chorus-services/backbeat/pkg/sdk/doc.go
@@ -0,0 +1,110 @@
+// Package sdk provides the BACKBEAT Go SDK for enabling CHORUS services
+// to become BACKBEAT-aware with beat synchronization and status emission.
+//
+// The BACKBEAT SDK enables services to:
+// - Subscribe to cluster-wide beat events with jitter tolerance
+// - Emit status claims with automatic metadata population
+// - Use beat budgets for timeout management
+// - Operate in local degradation mode when pulse unavailable
+// - Integrate comprehensive observability and health reporting
+//
+// # Quick Start
+//
+// config := sdk.DefaultConfig()
+// config.ClusterID = "chorus-dev"
+// config.AgentID = "my-service"
+// config.NATSUrl = "nats://localhost:4222"
+//
+// client := sdk.NewClient(config)
+//
+// client.OnBeat(func(beat sdk.BeatFrame) {
+// // Called every beat
+// client.EmitStatusClaim(sdk.StatusClaim{
+// State: "executing",
+// Progress: 0.5,
+// Notes: "Processing data",
+// })
+// })
+//
+// ctx := context.Background()
+// client.Start(ctx)
+// defer client.Stop()
+//
+// # Beat Subscription
+//
+// Register callbacks for beat and downbeat events:
+//
+// client.OnBeat(func(beat sdk.BeatFrame) {
+// // Called every beat (~1-4 times per second depending on tempo)
+// fmt.Printf("Beat %d\n", beat.BeatIndex)
+// })
+//
+// client.OnDownbeat(func(beat sdk.BeatFrame) {
+// // Called at the start of each bar (every 4 beats typically)
+// fmt.Printf("Bar started: %s\n", beat.WindowID)
+// })
+//
+// # Status Emission
+//
+// Emit status claims to report current state and progress:
+//
+// err := client.EmitStatusClaim(sdk.StatusClaim{
+// State: "executing", // executing|planning|waiting|review|done|failed
+// BeatsLeft: 10, // estimated beats remaining
+// Progress: 0.75, // progress ratio (0.0-1.0)
+// Notes: "Processing batch 5/10",
+// })
+//
+// # Beat Budgets
+//
+// Execute functions with beat-based timeouts:
+//
+// err := client.WithBeatBudget(10, func() error {
+// // This function has 10 beats to complete
+// return performLongRunningTask()
+// })
+//
+// if err != nil {
+// // Handle timeout or task error
+// log.Printf("Task failed or exceeded budget: %v", err)
+// }
+//
+// # Health and Observability
+//
+// Monitor client health and metrics:
+//
+// health := client.Health()
+// fmt.Printf("Connected: %v\n", health.Connected)
+// fmt.Printf("Last Beat: %d\n", health.LastBeat)
+// fmt.Printf("Reconnects: %d\n", health.ReconnectCount)
+//
+// # Local Degradation
+//
+// The SDK automatically handles network issues by entering local degradation mode:
+// - Generates synthetic beats when pulse service unavailable
+// - Uses fallback timing to maintain callback schedules
+// - Automatically recovers when pulse service returns
+// - Provides seamless operation during network partitions
+//
+// # Security
+//
+// The SDK implements BACKBEAT security requirements:
+// - Ed25519 signing of all status claims when key provided
+// - Required x-window-id and x-hlc headers
+// - Agent identification for proper message routing
+//
+// # Performance
+//
+// Designed for production use with:
+// - Beat callback latency target ≤5ms
+// - Timer drift ≤1% over 1 hour without leader
+// - Goroutine-safe concurrent operations
+// - Bounded memory usage for metrics and errors
+//
+// # Examples
+//
+// See the examples subdirectory for complete usage patterns:
+// - examples/simple_agent.go: Basic integration
+// - examples/task_processor.go: Beat budget usage
+// - examples/service_monitor.go: Health monitoring
+package sdk
\ No newline at end of file
diff --git a/vendor/github.com/chorus-services/backbeat/pkg/sdk/internal.go b/vendor/github.com/chorus-services/backbeat/pkg/sdk/internal.go
new file mode 100644
index 0000000..d424253
--- /dev/null
+++ b/vendor/github.com/chorus-services/backbeat/pkg/sdk/internal.go
@@ -0,0 +1,426 @@
+package sdk
+
+import (
+ "crypto/ed25519"
+ "crypto/sha256"
+ "encoding/json"
+ "fmt"
+ "time"
+
+ "github.com/nats-io/nats.go"
+)
+
+// connect establishes connection to NATS with retry logic
+func (c *client) connect() error {
+ opts := []nats.Option{
+ nats.ReconnectWait(c.config.ReconnectDelay),
+ nats.MaxReconnects(c.config.MaxReconnects),
+ nats.ReconnectHandler(func(nc *nats.Conn) {
+ c.reconnectCount++
+ c.metrics.RecordConnection()
+ c.config.Logger.Info("NATS reconnected",
+ "reconnect_count", c.reconnectCount,
+ "url", nc.ConnectedUrl())
+ }),
+ nats.DisconnectErrHandler(func(nc *nats.Conn, err error) {
+ if err != nil {
+ c.metrics.RecordDisconnection()
+ c.addError(fmt.Sprintf("NATS disconnected: %v", err))
+ c.config.Logger.Warn("NATS disconnected", "error", err)
+ }
+ }),
+ nats.ClosedHandler(func(nc *nats.Conn) {
+ c.metrics.RecordDisconnection()
+ c.config.Logger.Info("NATS connection closed")
+ }),
+ }
+
+ nc, err := nats.Connect(c.config.NATSUrl, opts...)
+ if err != nil {
+ c.metrics.RecordError(fmt.Sprintf("NATS connection failed: %v", err))
+ return fmt.Errorf("failed to connect to NATS: %w", err)
+ }
+
+ c.nc = nc
+ c.metrics.RecordConnection()
+ c.config.Logger.Info("Connected to NATS", "url", nc.ConnectedUrl())
+ return nil
+}
+
+// beatSubscriptionLoop handles beat frame subscription with jitter tolerance
+func (c *client) beatSubscriptionLoop() {
+ defer c.wg.Done()
+
+ subject := fmt.Sprintf("backbeat.beat.%s", c.config.ClusterID)
+
+ // Subscribe to beat frames
+ sub, err := c.nc.Subscribe(subject, c.handleBeatFrame)
+ if err != nil {
+ c.addError(fmt.Sprintf("failed to subscribe to beats: %v", err))
+ c.config.Logger.Error("Failed to subscribe to beats", "error", err)
+ return
+ }
+ defer sub.Unsubscribe()
+
+ c.config.Logger.Info("Beat subscription active", "subject", subject)
+
+ // Start local degradation timer for fallback timing
+ localTicker := time.NewTicker(1 * time.Second) // Default 60 BPM fallback
+ defer localTicker.Stop()
+
+ for {
+ select {
+ case <-c.ctx.Done():
+ return
+ case <-localTicker.C:
+ // Local degradation mode - generate synthetic beats if no recent beats
+ c.beatMutex.RLock()
+ timeSinceLastBeat := time.Since(c.lastBeatTime)
+ c.beatMutex.RUnlock()
+
+ // If more than 2 beat intervals have passed, enter degradation mode
+ if timeSinceLastBeat > 2*time.Second {
+ if !c.localDegradation {
+ c.localDegradation = true
+ c.config.Logger.Warn("Entering local degradation mode",
+ "time_since_last_beat", timeSinceLastBeat)
+ }
+
+ c.handleLocalDegradationBeat()
+ c.metrics.RecordLocalDegradation(timeSinceLastBeat)
+ } else if c.localDegradation {
+ // Exit degradation mode
+ c.localDegradation = false
+ c.config.Logger.Info("Exiting local degradation mode")
+ }
+ }
+ }
+}
+
+// handleBeatFrame processes incoming beat frames with jitter tolerance
+func (c *client) handleBeatFrame(msg *nats.Msg) {
+ var beatFrame BeatFrame
+ if err := json.Unmarshal(msg.Data, &beatFrame); err != nil {
+ c.addError(fmt.Sprintf("failed to unmarshal beat frame: %v", err))
+ return
+ }
+
+ // Validate beat frame
+ if beatFrame.Type != "backbeat.beatframe.v1" {
+ c.addError(fmt.Sprintf("invalid beat frame type: %s", beatFrame.Type))
+ return
+ }
+
+ // Check for jitter tolerance
+ now := time.Now()
+ expectedTime := beatFrame.DeadlineAt.Add(-c.getBeatDuration()) // Beat should arrive one duration before deadline
+ jitter := now.Sub(expectedTime)
+ if jitter.Abs() > c.config.JitterTolerance {
+ c.config.Logger.Debug("Beat jitter detected",
+ "jitter", jitter,
+ "tolerance", c.config.JitterTolerance,
+ "beat_index", beatFrame.BeatIndex)
+ }
+
+ // Update internal state
+ c.beatMutex.Lock()
+ c.currentBeat = beatFrame.BeatIndex
+ c.currentWindow = beatFrame.WindowID
+ c.currentHLC = beatFrame.HLC
+
+ // Track tempo changes and calculate actual BPM
+ if c.currentTempo != beatFrame.TempoBPM {
+ c.lastTempo = c.currentTempo
+ c.currentTempo = beatFrame.TempoBPM
+ }
+
+ // Calculate actual BPM from inter-beat timing
+ actualBPM := 60.0 // Default
+ if !c.lastBeatTime.IsZero() {
+ interBeatDuration := now.Sub(c.lastBeatTime)
+ if interBeatDuration > 0 {
+ actualBPM = 60.0 / interBeatDuration.Seconds()
+ }
+ }
+
+ // Record tempo sample for drift analysis
+ sample := tempoSample{
+ BeatIndex: beatFrame.BeatIndex,
+ Tempo: beatFrame.TempoBPM,
+ MeasuredTime: now,
+ ActualBPM: actualBPM,
+ }
+
+ c.tempoHistory = append(c.tempoHistory, sample)
+ // Keep only last 100 samples
+ if len(c.tempoHistory) > 100 {
+ c.tempoHistory = c.tempoHistory[1:]
+ }
+
+ c.lastBeatTime = now
+ c.beatMutex.Unlock()
+
+ // Record beat metrics
+ c.metrics.RecordBeat(beatFrame.DeadlineAt.Add(-c.getBeatDuration()), now, beatFrame.Downbeat)
+
+ // If we were in local degradation mode, exit it
+ if c.localDegradation {
+ c.localDegradation = false
+ c.config.Logger.Info("Exiting local degradation mode - beat received")
+ }
+
+ // Execute beat callbacks with error handling
+ c.callbackMutex.RLock()
+ beatCallbacks := make([]func(BeatFrame), len(c.beatCallbacks))
+ copy(beatCallbacks, c.beatCallbacks)
+
+ var downbeatCallbacks []func(BeatFrame)
+ if beatFrame.Downbeat {
+ downbeatCallbacks = make([]func(BeatFrame), len(c.downbeatCallbacks))
+ copy(downbeatCallbacks, c.downbeatCallbacks)
+ }
+ c.callbackMutex.RUnlock()
+
+ // Execute callbacks in separate goroutines to prevent blocking
+ for _, callback := range beatCallbacks {
+ go c.safeExecuteCallback(callback, beatFrame, "beat")
+ }
+
+ if beatFrame.Downbeat {
+ for _, callback := range downbeatCallbacks {
+ go c.safeExecuteCallback(callback, beatFrame, "downbeat")
+ }
+ }
+
+ c.config.Logger.Debug("Beat processed",
+ "beat_index", beatFrame.BeatIndex,
+ "downbeat", beatFrame.Downbeat,
+ "phase", beatFrame.Phase,
+ "window_id", beatFrame.WindowID)
+}
+
+// handleLocalDegradationBeat generates synthetic beats during network issues
+func (c *client) handleLocalDegradationBeat() {
+ c.beatMutex.Lock()
+ c.currentBeat++
+
+ // Generate synthetic beat frame
+ now := time.Now()
+ beatFrame := BeatFrame{
+ Type: "backbeat.beatframe.v1",
+ ClusterID: c.config.ClusterID,
+ BeatIndex: c.currentBeat,
+ Downbeat: (c.currentBeat-1)%4 == 0, // Assume 4/4 time signature
+ Phase: "degraded",
+ HLC: fmt.Sprintf("%d-0", now.UnixNano()),
+ DeadlineAt: now.Add(time.Second), // 1 second deadline in degradation
+ TempoBPM: 2, // Default 2 BPM (30-second beats) - reasonable for distributed systems
+ WindowID: c.generateDegradedWindowID(c.currentBeat),
+ }
+
+ c.currentWindow = beatFrame.WindowID
+ c.currentHLC = beatFrame.HLC
+ c.lastBeatTime = now
+ c.beatMutex.Unlock()
+
+ // Execute callbacks same as normal beats
+ c.callbackMutex.RLock()
+ beatCallbacks := make([]func(BeatFrame), len(c.beatCallbacks))
+ copy(beatCallbacks, c.beatCallbacks)
+
+ var downbeatCallbacks []func(BeatFrame)
+ if beatFrame.Downbeat {
+ downbeatCallbacks = make([]func(BeatFrame), len(c.downbeatCallbacks))
+ copy(downbeatCallbacks, c.downbeatCallbacks)
+ }
+ c.callbackMutex.RUnlock()
+
+ for _, callback := range beatCallbacks {
+ go c.safeExecuteCallback(callback, beatFrame, "degraded-beat")
+ }
+
+ if beatFrame.Downbeat {
+ for _, callback := range downbeatCallbacks {
+ go c.safeExecuteCallback(callback, beatFrame, "degraded-downbeat")
+ }
+ }
+}
+
+// safeExecuteCallback executes a callback with panic recovery
+func (c *client) safeExecuteCallback(callback func(BeatFrame), beat BeatFrame, callbackType string) {
+ defer func() {
+ if r := recover(); r != nil {
+ errMsg := fmt.Sprintf("panic in %s callback: %v", callbackType, r)
+ c.addError(errMsg)
+ c.metrics.RecordError(errMsg)
+ c.config.Logger.Error("Callback panic recovered",
+ "type", callbackType,
+ "panic", r,
+ "beat_index", beat.BeatIndex)
+ }
+ }()
+
+ start := time.Now()
+ callback(beat)
+ duration := time.Since(start)
+
+ // Record callback latency metrics
+ c.metrics.RecordCallbackLatency(duration, callbackType)
+
+ // Warn about slow callbacks
+ if duration > 5*time.Millisecond {
+ c.config.Logger.Warn("Slow callback detected",
+ "type", callbackType,
+ "duration", duration,
+ "beat_index", beat.BeatIndex)
+ }
+}
+
+// validateStatusClaim validates a status claim
+func (c *client) validateStatusClaim(claim *StatusClaim) error {
+ if claim.State == "" {
+ return fmt.Errorf("state is required")
+ }
+
+ validStates := map[string]bool{
+ "executing": true,
+ "planning": true,
+ "waiting": true,
+ "review": true,
+ "done": true,
+ "failed": true,
+ }
+
+ if !validStates[claim.State] {
+ return fmt.Errorf("invalid state: must be one of [executing, planning, waiting, review, done, failed], got '%s'", claim.State)
+ }
+
+ if claim.Progress < 0.0 || claim.Progress > 1.0 {
+ return fmt.Errorf("progress must be between 0.0 and 1.0, got %f", claim.Progress)
+ }
+
+ if claim.BeatsLeft < 0 {
+ return fmt.Errorf("beats_left must be non-negative, got %d", claim.BeatsLeft)
+ }
+
+ return nil
+}
+
+// signStatusClaim signs a status claim using Ed25519 (BACKBEAT-REQ-044)
+func (c *client) signStatusClaim(claim *StatusClaim) error {
+ if c.config.SigningKey == nil {
+ return fmt.Errorf("signing key not configured")
+ }
+
+ // Create canonical representation for signing
+ canonical, err := json.Marshal(claim)
+ if err != nil {
+ return fmt.Errorf("failed to marshal claim for signing: %w", err)
+ }
+
+ // Sign the canonical representation
+ signature := ed25519.Sign(c.config.SigningKey, canonical)
+
+ // Add signature to notes (temporary until proper signature field added)
+ claim.Notes += fmt.Sprintf(" [sig:%x]", signature)
+
+ return nil
+}
+
+// createHeaders creates NATS headers with required security information
+func (c *client) createHeaders() nats.Header {
+ headers := make(nats.Header)
+
+ // Add window ID header (BACKBEAT-REQ-044)
+ headers.Add("x-window-id", c.GetCurrentWindow())
+
+ // Add HLC header (BACKBEAT-REQ-044)
+ headers.Add("x-hlc", c.getCurrentHLC())
+
+ // Add agent ID for routing
+ headers.Add("x-agent-id", c.config.AgentID)
+
+ return headers
+}
+
+// getCurrentHLC returns the current HLC timestamp
+func (c *client) getCurrentHLC() string {
+ c.beatMutex.RLock()
+ defer c.beatMutex.RUnlock()
+
+ if c.currentHLC != "" {
+ return c.currentHLC
+ }
+
+ // Generate fallback HLC
+ return fmt.Sprintf("%d-0", time.Now().UnixNano())
+}
+
+// getBeatDuration calculates the duration of a beat based on current tempo
+func (c *client) getBeatDuration() time.Duration {
+ c.beatMutex.RLock()
+ tempo := c.currentTempo
+ c.beatMutex.RUnlock()
+
+ if tempo <= 0 {
+ tempo = 60 // Default to 60 BPM if no tempo information available
+ }
+
+ // Calculate beat duration: 60 seconds / BPM = seconds per beat
+ return time.Duration(60.0/float64(tempo)*1000) * time.Millisecond
+}
+
+// generateDegradedWindowID generates a window ID for degraded mode
+func (c *client) generateDegradedWindowID(beatIndex int64) string {
+ // Use similar algorithm to regular window ID but mark as degraded
+ input := fmt.Sprintf("%s:degraded:%d", c.config.ClusterID, beatIndex/4) // Assume 4-beat bars
+ hash := sha256.Sum256([]byte(input))
+ return fmt.Sprintf("deg-%x", hash)[:32]
+}
+
+// addError adds an error to the error list with deduplication
+func (c *client) addError(err string) {
+ c.errorMutex.Lock()
+ defer c.errorMutex.Unlock()
+
+ // Keep only the last 10 errors to prevent memory leaks
+ if len(c.errors) >= 10 {
+ c.errors = c.errors[1:]
+ }
+
+ timestampedErr := fmt.Sprintf("[%s] %s", time.Now().Format("15:04:05"), err)
+ c.errors = append(c.errors, timestampedErr)
+
+ // Record error in metrics
+ c.metrics.RecordError(timestampedErr)
+}
+
+// Legacy compatibility functions for BACKBEAT-REQ-043
+
+// ConvertLegacyBeat converts legacy {bar,beat} to beat_index with warning
+func (c *client) ConvertLegacyBeat(bar, beat int) int64 {
+ c.legacyMutex.Lock()
+ if !c.legacyWarned {
+ c.config.Logger.Warn("Legacy {bar,beat} format detected - please migrate to beat_index",
+ "bar", bar, "beat", beat)
+ c.legacyWarned = true
+ }
+ c.legacyMutex.Unlock()
+
+ // Convert assuming 4 beats per bar (standard)
+ return int64((bar-1)*4 + beat)
+}
+
+// GetLegacyBeatInfo converts current beat_index to legacy {bar,beat} format
+func (c *client) GetLegacyBeatInfo() LegacyBeatInfo {
+ beatIndex := c.GetCurrentBeat()
+ if beatIndex <= 0 {
+ return LegacyBeatInfo{Bar: 1, Beat: 1}
+ }
+
+ // Convert assuming 4 beats per bar
+ bar := int((beatIndex-1)/4) + 1
+ beat := int((beatIndex-1)%4) + 1
+
+ return LegacyBeatInfo{Bar: bar, Beat: beat}
+}
\ No newline at end of file
diff --git a/vendor/github.com/chorus-services/backbeat/pkg/sdk/metrics.go b/vendor/github.com/chorus-services/backbeat/pkg/sdk/metrics.go
new file mode 100644
index 0000000..be8b553
--- /dev/null
+++ b/vendor/github.com/chorus-services/backbeat/pkg/sdk/metrics.go
@@ -0,0 +1,277 @@
+package sdk
+
+import (
+ "expvar"
+ "fmt"
+ "sync"
+ "time"
+)
+
+// Metrics provides comprehensive observability for the SDK
+type Metrics struct {
+ // Connection metrics
+ ConnectionStatus *expvar.Int
+ ReconnectCount *expvar.Int
+ ConnectionDuration *expvar.Int
+
+ // Beat metrics
+ BeatsReceived *expvar.Int
+ DownbeatsReceived *expvar.Int
+ BeatJitterMS *expvar.Map
+ BeatCallbackLatency *expvar.Map
+ BeatMisses *expvar.Int
+ LocalDegradationTime *expvar.Int
+
+ // Status emission metrics
+ StatusClaimsEmitted *expvar.Int
+ StatusClaimErrors *expvar.Int
+
+ // Budget metrics
+ BudgetsCreated *expvar.Int
+ BudgetsCompleted *expvar.Int
+ BudgetsTimedOut *expvar.Int
+
+ // Error metrics
+ TotalErrors *expvar.Int
+ LastError *expvar.String
+
+ // Internal counters
+ beatJitterSamples []float64
+ jitterMutex sync.Mutex
+ callbackLatencies []float64
+ latencyMutex sync.Mutex
+}
+
+// NewMetrics creates a new metrics instance with expvar integration
+func NewMetrics(prefix string) *Metrics {
+ m := &Metrics{
+ ConnectionStatus: expvar.NewInt(prefix + ".connection.status"),
+ ReconnectCount: expvar.NewInt(prefix + ".connection.reconnects"),
+ ConnectionDuration: expvar.NewInt(prefix + ".connection.duration_ms"),
+
+ BeatsReceived: expvar.NewInt(prefix + ".beats.received"),
+ DownbeatsReceived: expvar.NewInt(prefix + ".beats.downbeats"),
+ BeatJitterMS: expvar.NewMap(prefix + ".beats.jitter_ms"),
+ BeatCallbackLatency: expvar.NewMap(prefix + ".beats.callback_latency_ms"),
+ BeatMisses: expvar.NewInt(prefix + ".beats.misses"),
+ LocalDegradationTime: expvar.NewInt(prefix + ".beats.degradation_ms"),
+
+ StatusClaimsEmitted: expvar.NewInt(prefix + ".status.claims_emitted"),
+ StatusClaimErrors: expvar.NewInt(prefix + ".status.claim_errors"),
+
+ BudgetsCreated: expvar.NewInt(prefix + ".budgets.created"),
+ BudgetsCompleted: expvar.NewInt(prefix + ".budgets.completed"),
+ BudgetsTimedOut: expvar.NewInt(prefix + ".budgets.timed_out"),
+
+ TotalErrors: expvar.NewInt(prefix + ".errors.total"),
+ LastError: expvar.NewString(prefix + ".errors.last"),
+
+ beatJitterSamples: make([]float64, 0, 100),
+ callbackLatencies: make([]float64, 0, 100),
+ }
+
+ // Initialize connection status to disconnected
+ m.ConnectionStatus.Set(0)
+
+ return m
+}
+
+// RecordConnection records connection establishment
+func (m *Metrics) RecordConnection() {
+ m.ConnectionStatus.Set(1)
+ m.ReconnectCount.Add(1)
+}
+
+// RecordDisconnection records connection loss
+func (m *Metrics) RecordDisconnection() {
+ m.ConnectionStatus.Set(0)
+}
+
+// RecordBeat records a beat reception with jitter measurement
+func (m *Metrics) RecordBeat(expectedTime, actualTime time.Time, isDownbeat bool) {
+ m.BeatsReceived.Add(1)
+ if isDownbeat {
+ m.DownbeatsReceived.Add(1)
+ }
+
+ // Calculate and record jitter
+ jitter := actualTime.Sub(expectedTime)
+ jitterMS := float64(jitter.Nanoseconds()) / 1e6
+
+ m.jitterMutex.Lock()
+ m.beatJitterSamples = append(m.beatJitterSamples, jitterMS)
+ if len(m.beatJitterSamples) > 100 {
+ m.beatJitterSamples = m.beatJitterSamples[1:]
+ }
+
+ // Update jitter statistics
+ if len(m.beatJitterSamples) > 0 {
+ avg, p95, p99 := m.calculatePercentiles(m.beatJitterSamples)
+ m.BeatJitterMS.Set("avg", &expvar.Float{})
+ m.BeatJitterMS.Get("avg").(*expvar.Float).Set(avg)
+ m.BeatJitterMS.Set("p95", &expvar.Float{})
+ m.BeatJitterMS.Get("p95").(*expvar.Float).Set(p95)
+ m.BeatJitterMS.Set("p99", &expvar.Float{})
+ m.BeatJitterMS.Get("p99").(*expvar.Float).Set(p99)
+ }
+ m.jitterMutex.Unlock()
+}
+
+// RecordBeatMiss records a missed beat
+func (m *Metrics) RecordBeatMiss() {
+ m.BeatMisses.Add(1)
+}
+
+// RecordCallbackLatency records callback execution latency
+func (m *Metrics) RecordCallbackLatency(duration time.Duration, callbackType string) {
+ latencyMS := float64(duration.Nanoseconds()) / 1e6
+
+ m.latencyMutex.Lock()
+ m.callbackLatencies = append(m.callbackLatencies, latencyMS)
+ if len(m.callbackLatencies) > 100 {
+ m.callbackLatencies = m.callbackLatencies[1:]
+ }
+
+ // Update latency statistics
+ if len(m.callbackLatencies) > 0 {
+ avg, p95, p99 := m.calculatePercentiles(m.callbackLatencies)
+ key := callbackType + "_avg"
+ m.BeatCallbackLatency.Set(key, &expvar.Float{})
+ m.BeatCallbackLatency.Get(key).(*expvar.Float).Set(avg)
+
+ key = callbackType + "_p95"
+ m.BeatCallbackLatency.Set(key, &expvar.Float{})
+ m.BeatCallbackLatency.Get(key).(*expvar.Float).Set(p95)
+
+ key = callbackType + "_p99"
+ m.BeatCallbackLatency.Set(key, &expvar.Float{})
+ m.BeatCallbackLatency.Get(key).(*expvar.Float).Set(p99)
+ }
+ m.latencyMutex.Unlock()
+}
+
+// RecordLocalDegradation records time spent in local degradation mode
+func (m *Metrics) RecordLocalDegradation(duration time.Duration) {
+ durationMS := duration.Nanoseconds() / 1e6
+ m.LocalDegradationTime.Add(durationMS)
+}
+
+// RecordStatusClaim records a status claim emission
+func (m *Metrics) RecordStatusClaim(success bool) {
+ if success {
+ m.StatusClaimsEmitted.Add(1)
+ } else {
+ m.StatusClaimErrors.Add(1)
+ }
+}
+
+// RecordBudget records budget creation and completion
+func (m *Metrics) RecordBudgetCreated() {
+ m.BudgetsCreated.Add(1)
+}
+
+func (m *Metrics) RecordBudgetCompleted(timedOut bool) {
+ if timedOut {
+ m.BudgetsTimedOut.Add(1)
+ } else {
+ m.BudgetsCompleted.Add(1)
+ }
+}
+
+// RecordError records an error
+func (m *Metrics) RecordError(err string) {
+ m.TotalErrors.Add(1)
+ m.LastError.Set(err)
+}
+
+// calculatePercentiles calculates avg, p95, p99 for a slice of samples
+func (m *Metrics) calculatePercentiles(samples []float64) (avg, p95, p99 float64) {
+ if len(samples) == 0 {
+ return 0, 0, 0
+ }
+
+ // Calculate average
+ sum := 0.0
+ for _, s := range samples {
+ sum += s
+ }
+ avg = sum / float64(len(samples))
+
+ // Sort for percentiles (simple bubble sort for small slices)
+ sorted := make([]float64, len(samples))
+ copy(sorted, samples)
+
+ for i := 0; i < len(sorted); i++ {
+ for j := 0; j < len(sorted)-i-1; j++ {
+ if sorted[j] > sorted[j+1] {
+ sorted[j], sorted[j+1] = sorted[j+1], sorted[j]
+ }
+ }
+ }
+
+ // Calculate percentiles
+ p95Index := int(float64(len(sorted)) * 0.95)
+ if p95Index >= len(sorted) {
+ p95Index = len(sorted) - 1
+ }
+ p95 = sorted[p95Index]
+
+ p99Index := int(float64(len(sorted)) * 0.99)
+ if p99Index >= len(sorted) {
+ p99Index = len(sorted) - 1
+ }
+ p99 = sorted[p99Index]
+
+ return avg, p95, p99
+}
+
+// Enhanced client with metrics integration
+func (c *client) initMetrics() {
+ prefix := fmt.Sprintf("backbeat.sdk.%s", c.config.AgentID)
+ c.metrics = NewMetrics(prefix)
+}
+
+// Add metrics field to client struct (this would go in client.go)
+type clientWithMetrics struct {
+ *client
+ metrics *Metrics
+}
+
+// Prometheus integration helper
+type PrometheusMetrics struct {
+ // This would integrate with prometheus/client_golang
+ // For now, we'll just use expvar which can be scraped
+}
+
+// GetMetricsSnapshot returns a snapshot of all current metrics
+func (m *Metrics) GetMetricsSnapshot() map[string]interface{} {
+ snapshot := make(map[string]interface{})
+
+ snapshot["connection_status"] = m.ConnectionStatus.Value()
+ snapshot["reconnect_count"] = m.ReconnectCount.Value()
+ snapshot["beats_received"] = m.BeatsReceived.Value()
+ snapshot["downbeats_received"] = m.DownbeatsReceived.Value()
+ snapshot["beat_misses"] = m.BeatMisses.Value()
+ snapshot["status_claims_emitted"] = m.StatusClaimsEmitted.Value()
+ snapshot["status_claim_errors"] = m.StatusClaimErrors.Value()
+ snapshot["budgets_created"] = m.BudgetsCreated.Value()
+ snapshot["budgets_completed"] = m.BudgetsCompleted.Value()
+ snapshot["budgets_timed_out"] = m.BudgetsTimedOut.Value()
+ snapshot["total_errors"] = m.TotalErrors.Value()
+ snapshot["last_error"] = m.LastError.Value()
+
+ return snapshot
+}
+
+// Health check with metrics
+func (c *client) GetHealthWithMetrics() map[string]interface{} {
+ health := map[string]interface{}{
+ "status": c.Health(),
+ }
+
+ if c.metrics != nil {
+ health["metrics"] = c.metrics.GetMetricsSnapshot()
+ }
+
+ return health
+}
\ No newline at end of file
diff --git a/vendor/github.com/docker/distribution/LICENSE b/vendor/github.com/docker/distribution/LICENSE
new file mode 100644
index 0000000..e06d208
--- /dev/null
+++ b/vendor/github.com/docker/distribution/LICENSE
@@ -0,0 +1,202 @@
+Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "{}"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright {yyyy} {name of copyright owner}
+
+ 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.
+
diff --git a/vendor/github.com/docker/distribution/digestset/set.go b/vendor/github.com/docker/distribution/digestset/set.go
new file mode 100644
index 0000000..71327dc
--- /dev/null
+++ b/vendor/github.com/docker/distribution/digestset/set.go
@@ -0,0 +1,247 @@
+package digestset
+
+import (
+ "errors"
+ "sort"
+ "strings"
+ "sync"
+
+ digest "github.com/opencontainers/go-digest"
+)
+
+var (
+ // ErrDigestNotFound is used when a matching digest
+ // could not be found in a set.
+ ErrDigestNotFound = errors.New("digest not found")
+
+ // ErrDigestAmbiguous is used when multiple digests
+ // are found in a set. None of the matching digests
+ // should be considered valid matches.
+ ErrDigestAmbiguous = errors.New("ambiguous digest string")
+)
+
+// Set is used to hold a unique set of digests which
+// may be easily referenced by easily referenced by a string
+// representation of the digest as well as short representation.
+// The uniqueness of the short representation is based on other
+// digests in the set. If digests are omitted from this set,
+// collisions in a larger set may not be detected, therefore it
+// is important to always do short representation lookups on
+// the complete set of digests. To mitigate collisions, an
+// appropriately long short code should be used.
+type Set struct {
+ mutex sync.RWMutex
+ entries digestEntries
+}
+
+// NewSet creates an empty set of digests
+// which may have digests added.
+func NewSet() *Set {
+ return &Set{
+ entries: digestEntries{},
+ }
+}
+
+// checkShortMatch checks whether two digests match as either whole
+// values or short values. This function does not test equality,
+// rather whether the second value could match against the first
+// value.
+func checkShortMatch(alg digest.Algorithm, hex, shortAlg, shortHex string) bool {
+ if len(hex) == len(shortHex) {
+ if hex != shortHex {
+ return false
+ }
+ if len(shortAlg) > 0 && string(alg) != shortAlg {
+ return false
+ }
+ } else if !strings.HasPrefix(hex, shortHex) {
+ return false
+ } else if len(shortAlg) > 0 && string(alg) != shortAlg {
+ return false
+ }
+ return true
+}
+
+// Lookup looks for a digest matching the given string representation.
+// If no digests could be found ErrDigestNotFound will be returned
+// with an empty digest value. If multiple matches are found
+// ErrDigestAmbiguous will be returned with an empty digest value.
+func (dst *Set) Lookup(d string) (digest.Digest, error) {
+ dst.mutex.RLock()
+ defer dst.mutex.RUnlock()
+ if len(dst.entries) == 0 {
+ return "", ErrDigestNotFound
+ }
+ var (
+ searchFunc func(int) bool
+ alg digest.Algorithm
+ hex string
+ )
+ dgst, err := digest.Parse(d)
+ if err == digest.ErrDigestInvalidFormat {
+ hex = d
+ searchFunc = func(i int) bool {
+ return dst.entries[i].val >= d
+ }
+ } else {
+ hex = dgst.Hex()
+ alg = dgst.Algorithm()
+ searchFunc = func(i int) bool {
+ if dst.entries[i].val == hex {
+ return dst.entries[i].alg >= alg
+ }
+ return dst.entries[i].val >= hex
+ }
+ }
+ idx := sort.Search(len(dst.entries), searchFunc)
+ if idx == len(dst.entries) || !checkShortMatch(dst.entries[idx].alg, dst.entries[idx].val, string(alg), hex) {
+ return "", ErrDigestNotFound
+ }
+ if dst.entries[idx].alg == alg && dst.entries[idx].val == hex {
+ return dst.entries[idx].digest, nil
+ }
+ if idx+1 < len(dst.entries) && checkShortMatch(dst.entries[idx+1].alg, dst.entries[idx+1].val, string(alg), hex) {
+ return "", ErrDigestAmbiguous
+ }
+
+ return dst.entries[idx].digest, nil
+}
+
+// Add adds the given digest to the set. An error will be returned
+// if the given digest is invalid. If the digest already exists in the
+// set, this operation will be a no-op.
+func (dst *Set) Add(d digest.Digest) error {
+ if err := d.Validate(); err != nil {
+ return err
+ }
+ dst.mutex.Lock()
+ defer dst.mutex.Unlock()
+ entry := &digestEntry{alg: d.Algorithm(), val: d.Hex(), digest: d}
+ searchFunc := func(i int) bool {
+ if dst.entries[i].val == entry.val {
+ return dst.entries[i].alg >= entry.alg
+ }
+ return dst.entries[i].val >= entry.val
+ }
+ idx := sort.Search(len(dst.entries), searchFunc)
+ if idx == len(dst.entries) {
+ dst.entries = append(dst.entries, entry)
+ return nil
+ } else if dst.entries[idx].digest == d {
+ return nil
+ }
+
+ entries := append(dst.entries, nil)
+ copy(entries[idx+1:], entries[idx:len(entries)-1])
+ entries[idx] = entry
+ dst.entries = entries
+ return nil
+}
+
+// Remove removes the given digest from the set. An err will be
+// returned if the given digest is invalid. If the digest does
+// not exist in the set, this operation will be a no-op.
+func (dst *Set) Remove(d digest.Digest) error {
+ if err := d.Validate(); err != nil {
+ return err
+ }
+ dst.mutex.Lock()
+ defer dst.mutex.Unlock()
+ entry := &digestEntry{alg: d.Algorithm(), val: d.Hex(), digest: d}
+ searchFunc := func(i int) bool {
+ if dst.entries[i].val == entry.val {
+ return dst.entries[i].alg >= entry.alg
+ }
+ return dst.entries[i].val >= entry.val
+ }
+ idx := sort.Search(len(dst.entries), searchFunc)
+ // Not found if idx is after or value at idx is not digest
+ if idx == len(dst.entries) || dst.entries[idx].digest != d {
+ return nil
+ }
+
+ entries := dst.entries
+ copy(entries[idx:], entries[idx+1:])
+ entries = entries[:len(entries)-1]
+ dst.entries = entries
+
+ return nil
+}
+
+// All returns all the digests in the set
+func (dst *Set) All() []digest.Digest {
+ dst.mutex.RLock()
+ defer dst.mutex.RUnlock()
+ retValues := make([]digest.Digest, len(dst.entries))
+ for i := range dst.entries {
+ retValues[i] = dst.entries[i].digest
+ }
+
+ return retValues
+}
+
+// ShortCodeTable returns a map of Digest to unique short codes. The
+// length represents the minimum value, the maximum length may be the
+// entire value of digest if uniqueness cannot be achieved without the
+// full value. This function will attempt to make short codes as short
+// as possible to be unique.
+func ShortCodeTable(dst *Set, length int) map[digest.Digest]string {
+ dst.mutex.RLock()
+ defer dst.mutex.RUnlock()
+ m := make(map[digest.Digest]string, len(dst.entries))
+ l := length
+ resetIdx := 0
+ for i := 0; i < len(dst.entries); i++ {
+ var short string
+ extended := true
+ for extended {
+ extended = false
+ if len(dst.entries[i].val) <= l {
+ short = dst.entries[i].digest.String()
+ } else {
+ short = dst.entries[i].val[:l]
+ for j := i + 1; j < len(dst.entries); j++ {
+ if checkShortMatch(dst.entries[j].alg, dst.entries[j].val, "", short) {
+ if j > resetIdx {
+ resetIdx = j
+ }
+ extended = true
+ } else {
+ break
+ }
+ }
+ if extended {
+ l++
+ }
+ }
+ }
+ m[dst.entries[i].digest] = short
+ if i >= resetIdx {
+ l = length
+ }
+ }
+ return m
+}
+
+type digestEntry struct {
+ alg digest.Algorithm
+ val string
+ digest digest.Digest
+}
+
+type digestEntries []*digestEntry
+
+func (d digestEntries) Len() int {
+ return len(d)
+}
+
+func (d digestEntries) Less(i, j int) bool {
+ if d[i].val != d[j].val {
+ return d[i].val < d[j].val
+ }
+ return d[i].alg < d[j].alg
+}
+
+func (d digestEntries) Swap(i, j int) {
+ d[i], d[j] = d[j], d[i]
+}
diff --git a/vendor/github.com/docker/distribution/reference/helpers.go b/vendor/github.com/docker/distribution/reference/helpers.go
new file mode 100644
index 0000000..978df7e
--- /dev/null
+++ b/vendor/github.com/docker/distribution/reference/helpers.go
@@ -0,0 +1,42 @@
+package reference
+
+import "path"
+
+// IsNameOnly returns true if reference only contains a repo name.
+func IsNameOnly(ref Named) bool {
+ if _, ok := ref.(NamedTagged); ok {
+ return false
+ }
+ if _, ok := ref.(Canonical); ok {
+ return false
+ }
+ return true
+}
+
+// FamiliarName returns the familiar name string
+// for the given named, familiarizing if needed.
+func FamiliarName(ref Named) string {
+ if nn, ok := ref.(normalizedNamed); ok {
+ return nn.Familiar().Name()
+ }
+ return ref.Name()
+}
+
+// FamiliarString returns the familiar string representation
+// for the given reference, familiarizing if needed.
+func FamiliarString(ref Reference) string {
+ if nn, ok := ref.(normalizedNamed); ok {
+ return nn.Familiar().String()
+ }
+ return ref.String()
+}
+
+// FamiliarMatch reports whether ref matches the specified pattern.
+// See https://godoc.org/path#Match for supported patterns.
+func FamiliarMatch(pattern string, ref Reference) (bool, error) {
+ matched, err := path.Match(pattern, FamiliarString(ref))
+ if namedRef, isNamed := ref.(Named); isNamed && !matched {
+ matched, _ = path.Match(pattern, FamiliarName(namedRef))
+ }
+ return matched, err
+}
diff --git a/vendor/github.com/docker/distribution/reference/normalize.go b/vendor/github.com/docker/distribution/reference/normalize.go
new file mode 100644
index 0000000..b3dfb7a
--- /dev/null
+++ b/vendor/github.com/docker/distribution/reference/normalize.go
@@ -0,0 +1,199 @@
+package reference
+
+import (
+ "errors"
+ "fmt"
+ "strings"
+
+ "github.com/docker/distribution/digestset"
+ "github.com/opencontainers/go-digest"
+)
+
+var (
+ legacyDefaultDomain = "index.docker.io"
+ defaultDomain = "docker.io"
+ officialRepoName = "library"
+ defaultTag = "latest"
+)
+
+// normalizedNamed represents a name which has been
+// normalized and has a familiar form. A familiar name
+// is what is used in Docker UI. An example normalized
+// name is "docker.io/library/ubuntu" and corresponding
+// familiar name of "ubuntu".
+type normalizedNamed interface {
+ Named
+ Familiar() Named
+}
+
+// ParseNormalizedNamed parses a string into a named reference
+// transforming a familiar name from Docker UI to a fully
+// qualified reference. If the value may be an identifier
+// use ParseAnyReference.
+func ParseNormalizedNamed(s string) (Named, error) {
+ if ok := anchoredIdentifierRegexp.MatchString(s); ok {
+ return nil, fmt.Errorf("invalid repository name (%s), cannot specify 64-byte hexadecimal strings", s)
+ }
+ domain, remainder := splitDockerDomain(s)
+ var remoteName string
+ if tagSep := strings.IndexRune(remainder, ':'); tagSep > -1 {
+ remoteName = remainder[:tagSep]
+ } else {
+ remoteName = remainder
+ }
+ if strings.ToLower(remoteName) != remoteName {
+ return nil, errors.New("invalid reference format: repository name must be lowercase")
+ }
+
+ ref, err := Parse(domain + "/" + remainder)
+ if err != nil {
+ return nil, err
+ }
+ named, isNamed := ref.(Named)
+ if !isNamed {
+ return nil, fmt.Errorf("reference %s has no name", ref.String())
+ }
+ return named, nil
+}
+
+// ParseDockerRef normalizes the image reference following the docker convention. This is added
+// mainly for backward compatibility.
+// The reference returned can only be either tagged or digested. For reference contains both tag
+// and digest, the function returns digested reference, e.g. docker.io/library/busybox:latest@
+// sha256:7cc4b5aefd1d0cadf8d97d4350462ba51c694ebca145b08d7d41b41acc8db5aa will be returned as
+// docker.io/library/busybox@sha256:7cc4b5aefd1d0cadf8d97d4350462ba51c694ebca145b08d7d41b41acc8db5aa.
+func ParseDockerRef(ref string) (Named, error) {
+ named, err := ParseNormalizedNamed(ref)
+ if err != nil {
+ return nil, err
+ }
+ if _, ok := named.(NamedTagged); ok {
+ if canonical, ok := named.(Canonical); ok {
+ // The reference is both tagged and digested, only
+ // return digested.
+ newNamed, err := WithName(canonical.Name())
+ if err != nil {
+ return nil, err
+ }
+ newCanonical, err := WithDigest(newNamed, canonical.Digest())
+ if err != nil {
+ return nil, err
+ }
+ return newCanonical, nil
+ }
+ }
+ return TagNameOnly(named), nil
+}
+
+// splitDockerDomain splits a repository name to domain and remotename string.
+// If no valid domain is found, the default domain is used. Repository name
+// needs to be already validated before.
+func splitDockerDomain(name string) (domain, remainder string) {
+ i := strings.IndexRune(name, '/')
+ if i == -1 || (!strings.ContainsAny(name[:i], ".:") && name[:i] != "localhost") {
+ domain, remainder = defaultDomain, name
+ } else {
+ domain, remainder = name[:i], name[i+1:]
+ }
+ if domain == legacyDefaultDomain {
+ domain = defaultDomain
+ }
+ if domain == defaultDomain && !strings.ContainsRune(remainder, '/') {
+ remainder = officialRepoName + "/" + remainder
+ }
+ return
+}
+
+// familiarizeName returns a shortened version of the name familiar
+// to to the Docker UI. Familiar names have the default domain
+// "docker.io" and "library/" repository prefix removed.
+// For example, "docker.io/library/redis" will have the familiar
+// name "redis" and "docker.io/dmcgowan/myapp" will be "dmcgowan/myapp".
+// Returns a familiarized named only reference.
+func familiarizeName(named namedRepository) repository {
+ repo := repository{
+ domain: named.Domain(),
+ path: named.Path(),
+ }
+
+ if repo.domain == defaultDomain {
+ repo.domain = ""
+ // Handle official repositories which have the pattern "library/"
+ if split := strings.Split(repo.path, "/"); len(split) == 2 && split[0] == officialRepoName {
+ repo.path = split[1]
+ }
+ }
+ return repo
+}
+
+func (r reference) Familiar() Named {
+ return reference{
+ namedRepository: familiarizeName(r.namedRepository),
+ tag: r.tag,
+ digest: r.digest,
+ }
+}
+
+func (r repository) Familiar() Named {
+ return familiarizeName(r)
+}
+
+func (t taggedReference) Familiar() Named {
+ return taggedReference{
+ namedRepository: familiarizeName(t.namedRepository),
+ tag: t.tag,
+ }
+}
+
+func (c canonicalReference) Familiar() Named {
+ return canonicalReference{
+ namedRepository: familiarizeName(c.namedRepository),
+ digest: c.digest,
+ }
+}
+
+// TagNameOnly adds the default tag "latest" to a reference if it only has
+// a repo name.
+func TagNameOnly(ref Named) Named {
+ if IsNameOnly(ref) {
+ namedTagged, err := WithTag(ref, defaultTag)
+ if err != nil {
+ // Default tag must be valid, to create a NamedTagged
+ // type with non-validated input the WithTag function
+ // should be used instead
+ panic(err)
+ }
+ return namedTagged
+ }
+ return ref
+}
+
+// ParseAnyReference parses a reference string as a possible identifier,
+// full digest, or familiar name.
+func ParseAnyReference(ref string) (Reference, error) {
+ if ok := anchoredIdentifierRegexp.MatchString(ref); ok {
+ return digestReference("sha256:" + ref), nil
+ }
+ if dgst, err := digest.Parse(ref); err == nil {
+ return digestReference(dgst), nil
+ }
+
+ return ParseNormalizedNamed(ref)
+}
+
+// ParseAnyReferenceWithSet parses a reference string as a possible short
+// identifier to be matched in a digest set, a full digest, or familiar name.
+func ParseAnyReferenceWithSet(ref string, ds *digestset.Set) (Reference, error) {
+ if ok := anchoredShortIdentifierRegexp.MatchString(ref); ok {
+ dgst, err := ds.Lookup(ref)
+ if err == nil {
+ return digestReference(dgst), nil
+ }
+ } else {
+ if dgst, err := digest.Parse(ref); err == nil {
+ return digestReference(dgst), nil
+ }
+ }
+
+ return ParseNormalizedNamed(ref)
+}
diff --git a/vendor/github.com/docker/distribution/reference/reference.go b/vendor/github.com/docker/distribution/reference/reference.go
new file mode 100644
index 0000000..b7cd00b
--- /dev/null
+++ b/vendor/github.com/docker/distribution/reference/reference.go
@@ -0,0 +1,433 @@
+// Package reference provides a general type to represent any way of referencing images within the registry.
+// Its main purpose is to abstract tags and digests (content-addressable hash).
+//
+// Grammar
+//
+// reference := name [ ":" tag ] [ "@" digest ]
+// name := [domain '/'] path-component ['/' path-component]*
+// domain := domain-component ['.' domain-component]* [':' port-number]
+// domain-component := /([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9])/
+// port-number := /[0-9]+/
+// path-component := alpha-numeric [separator alpha-numeric]*
+// alpha-numeric := /[a-z0-9]+/
+// separator := /[_.]|__|[-]*/
+//
+// tag := /[\w][\w.-]{0,127}/
+//
+// digest := digest-algorithm ":" digest-hex
+// digest-algorithm := digest-algorithm-component [ digest-algorithm-separator digest-algorithm-component ]*
+// digest-algorithm-separator := /[+.-_]/
+// digest-algorithm-component := /[A-Za-z][A-Za-z0-9]*/
+// digest-hex := /[0-9a-fA-F]{32,}/ ; At least 128 bit digest value
+//
+// identifier := /[a-f0-9]{64}/
+// short-identifier := /[a-f0-9]{6,64}/
+package reference
+
+import (
+ "errors"
+ "fmt"
+ "strings"
+
+ "github.com/opencontainers/go-digest"
+)
+
+const (
+ // NameTotalLengthMax is the maximum total number of characters in a repository name.
+ NameTotalLengthMax = 255
+)
+
+var (
+ // ErrReferenceInvalidFormat represents an error while trying to parse a string as a reference.
+ ErrReferenceInvalidFormat = errors.New("invalid reference format")
+
+ // ErrTagInvalidFormat represents an error while trying to parse a string as a tag.
+ ErrTagInvalidFormat = errors.New("invalid tag format")
+
+ // ErrDigestInvalidFormat represents an error while trying to parse a string as a tag.
+ ErrDigestInvalidFormat = errors.New("invalid digest format")
+
+ // ErrNameContainsUppercase is returned for invalid repository names that contain uppercase characters.
+ ErrNameContainsUppercase = errors.New("repository name must be lowercase")
+
+ // ErrNameEmpty is returned for empty, invalid repository names.
+ ErrNameEmpty = errors.New("repository name must have at least one component")
+
+ // ErrNameTooLong is returned when a repository name is longer than NameTotalLengthMax.
+ ErrNameTooLong = fmt.Errorf("repository name must not be more than %v characters", NameTotalLengthMax)
+
+ // ErrNameNotCanonical is returned when a name is not canonical.
+ ErrNameNotCanonical = errors.New("repository name must be canonical")
+)
+
+// Reference is an opaque object reference identifier that may include
+// modifiers such as a hostname, name, tag, and digest.
+type Reference interface {
+ // String returns the full reference
+ String() string
+}
+
+// Field provides a wrapper type for resolving correct reference types when
+// working with encoding.
+type Field struct {
+ reference Reference
+}
+
+// AsField wraps a reference in a Field for encoding.
+func AsField(reference Reference) Field {
+ return Field{reference}
+}
+
+// Reference unwraps the reference type from the field to
+// return the Reference object. This object should be
+// of the appropriate type to further check for different
+// reference types.
+func (f Field) Reference() Reference {
+ return f.reference
+}
+
+// MarshalText serializes the field to byte text which
+// is the string of the reference.
+func (f Field) MarshalText() (p []byte, err error) {
+ return []byte(f.reference.String()), nil
+}
+
+// UnmarshalText parses text bytes by invoking the
+// reference parser to ensure the appropriately
+// typed reference object is wrapped by field.
+func (f *Field) UnmarshalText(p []byte) error {
+ r, err := Parse(string(p))
+ if err != nil {
+ return err
+ }
+
+ f.reference = r
+ return nil
+}
+
+// Named is an object with a full name
+type Named interface {
+ Reference
+ Name() string
+}
+
+// Tagged is an object which has a tag
+type Tagged interface {
+ Reference
+ Tag() string
+}
+
+// NamedTagged is an object including a name and tag.
+type NamedTagged interface {
+ Named
+ Tag() string
+}
+
+// Digested is an object which has a digest
+// in which it can be referenced by
+type Digested interface {
+ Reference
+ Digest() digest.Digest
+}
+
+// Canonical reference is an object with a fully unique
+// name including a name with domain and digest
+type Canonical interface {
+ Named
+ Digest() digest.Digest
+}
+
+// namedRepository is a reference to a repository with a name.
+// A namedRepository has both domain and path components.
+type namedRepository interface {
+ Named
+ Domain() string
+ Path() string
+}
+
+// Domain returns the domain part of the Named reference
+func Domain(named Named) string {
+ if r, ok := named.(namedRepository); ok {
+ return r.Domain()
+ }
+ domain, _ := splitDomain(named.Name())
+ return domain
+}
+
+// Path returns the name without the domain part of the Named reference
+func Path(named Named) (name string) {
+ if r, ok := named.(namedRepository); ok {
+ return r.Path()
+ }
+ _, path := splitDomain(named.Name())
+ return path
+}
+
+func splitDomain(name string) (string, string) {
+ match := anchoredNameRegexp.FindStringSubmatch(name)
+ if len(match) != 3 {
+ return "", name
+ }
+ return match[1], match[2]
+}
+
+// SplitHostname splits a named reference into a
+// hostname and name string. If no valid hostname is
+// found, the hostname is empty and the full value
+// is returned as name
+// DEPRECATED: Use Domain or Path
+func SplitHostname(named Named) (string, string) {
+ if r, ok := named.(namedRepository); ok {
+ return r.Domain(), r.Path()
+ }
+ return splitDomain(named.Name())
+}
+
+// Parse parses s and returns a syntactically valid Reference.
+// If an error was encountered it is returned, along with a nil Reference.
+// NOTE: Parse will not handle short digests.
+func Parse(s string) (Reference, error) {
+ matches := ReferenceRegexp.FindStringSubmatch(s)
+ if matches == nil {
+ if s == "" {
+ return nil, ErrNameEmpty
+ }
+ if ReferenceRegexp.FindStringSubmatch(strings.ToLower(s)) != nil {
+ return nil, ErrNameContainsUppercase
+ }
+ return nil, ErrReferenceInvalidFormat
+ }
+
+ if len(matches[1]) > NameTotalLengthMax {
+ return nil, ErrNameTooLong
+ }
+
+ var repo repository
+
+ nameMatch := anchoredNameRegexp.FindStringSubmatch(matches[1])
+ if len(nameMatch) == 3 {
+ repo.domain = nameMatch[1]
+ repo.path = nameMatch[2]
+ } else {
+ repo.domain = ""
+ repo.path = matches[1]
+ }
+
+ ref := reference{
+ namedRepository: repo,
+ tag: matches[2],
+ }
+ if matches[3] != "" {
+ var err error
+ ref.digest, err = digest.Parse(matches[3])
+ if err != nil {
+ return nil, err
+ }
+ }
+
+ r := getBestReferenceType(ref)
+ if r == nil {
+ return nil, ErrNameEmpty
+ }
+
+ return r, nil
+}
+
+// ParseNamed parses s and returns a syntactically valid reference implementing
+// the Named interface. The reference must have a name and be in the canonical
+// form, otherwise an error is returned.
+// If an error was encountered it is returned, along with a nil Reference.
+// NOTE: ParseNamed will not handle short digests.
+func ParseNamed(s string) (Named, error) {
+ named, err := ParseNormalizedNamed(s)
+ if err != nil {
+ return nil, err
+ }
+ if named.String() != s {
+ return nil, ErrNameNotCanonical
+ }
+ return named, nil
+}
+
+// WithName returns a named object representing the given string. If the input
+// is invalid ErrReferenceInvalidFormat will be returned.
+func WithName(name string) (Named, error) {
+ if len(name) > NameTotalLengthMax {
+ return nil, ErrNameTooLong
+ }
+
+ match := anchoredNameRegexp.FindStringSubmatch(name)
+ if match == nil || len(match) != 3 {
+ return nil, ErrReferenceInvalidFormat
+ }
+ return repository{
+ domain: match[1],
+ path: match[2],
+ }, nil
+}
+
+// WithTag combines the name from "name" and the tag from "tag" to form a
+// reference incorporating both the name and the tag.
+func WithTag(name Named, tag string) (NamedTagged, error) {
+ if !anchoredTagRegexp.MatchString(tag) {
+ return nil, ErrTagInvalidFormat
+ }
+ var repo repository
+ if r, ok := name.(namedRepository); ok {
+ repo.domain = r.Domain()
+ repo.path = r.Path()
+ } else {
+ repo.path = name.Name()
+ }
+ if canonical, ok := name.(Canonical); ok {
+ return reference{
+ namedRepository: repo,
+ tag: tag,
+ digest: canonical.Digest(),
+ }, nil
+ }
+ return taggedReference{
+ namedRepository: repo,
+ tag: tag,
+ }, nil
+}
+
+// WithDigest combines the name from "name" and the digest from "digest" to form
+// a reference incorporating both the name and the digest.
+func WithDigest(name Named, digest digest.Digest) (Canonical, error) {
+ if !anchoredDigestRegexp.MatchString(digest.String()) {
+ return nil, ErrDigestInvalidFormat
+ }
+ var repo repository
+ if r, ok := name.(namedRepository); ok {
+ repo.domain = r.Domain()
+ repo.path = r.Path()
+ } else {
+ repo.path = name.Name()
+ }
+ if tagged, ok := name.(Tagged); ok {
+ return reference{
+ namedRepository: repo,
+ tag: tagged.Tag(),
+ digest: digest,
+ }, nil
+ }
+ return canonicalReference{
+ namedRepository: repo,
+ digest: digest,
+ }, nil
+}
+
+// TrimNamed removes any tag or digest from the named reference.
+func TrimNamed(ref Named) Named {
+ domain, path := SplitHostname(ref)
+ return repository{
+ domain: domain,
+ path: path,
+ }
+}
+
+func getBestReferenceType(ref reference) Reference {
+ if ref.Name() == "" {
+ // Allow digest only references
+ if ref.digest != "" {
+ return digestReference(ref.digest)
+ }
+ return nil
+ }
+ if ref.tag == "" {
+ if ref.digest != "" {
+ return canonicalReference{
+ namedRepository: ref.namedRepository,
+ digest: ref.digest,
+ }
+ }
+ return ref.namedRepository
+ }
+ if ref.digest == "" {
+ return taggedReference{
+ namedRepository: ref.namedRepository,
+ tag: ref.tag,
+ }
+ }
+
+ return ref
+}
+
+type reference struct {
+ namedRepository
+ tag string
+ digest digest.Digest
+}
+
+func (r reference) String() string {
+ return r.Name() + ":" + r.tag + "@" + r.digest.String()
+}
+
+func (r reference) Tag() string {
+ return r.tag
+}
+
+func (r reference) Digest() digest.Digest {
+ return r.digest
+}
+
+type repository struct {
+ domain string
+ path string
+}
+
+func (r repository) String() string {
+ return r.Name()
+}
+
+func (r repository) Name() string {
+ if r.domain == "" {
+ return r.path
+ }
+ return r.domain + "/" + r.path
+}
+
+func (r repository) Domain() string {
+ return r.domain
+}
+
+func (r repository) Path() string {
+ return r.path
+}
+
+type digestReference digest.Digest
+
+func (d digestReference) String() string {
+ return digest.Digest(d).String()
+}
+
+func (d digestReference) Digest() digest.Digest {
+ return digest.Digest(d)
+}
+
+type taggedReference struct {
+ namedRepository
+ tag string
+}
+
+func (t taggedReference) String() string {
+ return t.Name() + ":" + t.tag
+}
+
+func (t taggedReference) Tag() string {
+ return t.tag
+}
+
+type canonicalReference struct {
+ namedRepository
+ digest digest.Digest
+}
+
+func (c canonicalReference) String() string {
+ return c.Name() + "@" + c.digest.String()
+}
+
+func (c canonicalReference) Digest() digest.Digest {
+ return c.digest
+}
diff --git a/vendor/github.com/docker/distribution/reference/regexp.go b/vendor/github.com/docker/distribution/reference/regexp.go
new file mode 100644
index 0000000..7860349
--- /dev/null
+++ b/vendor/github.com/docker/distribution/reference/regexp.go
@@ -0,0 +1,143 @@
+package reference
+
+import "regexp"
+
+var (
+ // alphaNumericRegexp defines the alpha numeric atom, typically a
+ // component of names. This only allows lower case characters and digits.
+ alphaNumericRegexp = match(`[a-z0-9]+`)
+
+ // separatorRegexp defines the separators allowed to be embedded in name
+ // components. This allow one period, one or two underscore and multiple
+ // dashes.
+ separatorRegexp = match(`(?:[._]|__|[-]*)`)
+
+ // nameComponentRegexp restricts registry path component names to start
+ // with at least one letter or number, with following parts able to be
+ // separated by one period, one or two underscore and multiple dashes.
+ nameComponentRegexp = expression(
+ alphaNumericRegexp,
+ optional(repeated(separatorRegexp, alphaNumericRegexp)))
+
+ // domainComponentRegexp restricts the registry domain component of a
+ // repository name to start with a component as defined by DomainRegexp
+ // and followed by an optional port.
+ domainComponentRegexp = match(`(?:[a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9])`)
+
+ // DomainRegexp defines the structure of potential domain components
+ // that may be part of image names. This is purposely a subset of what is
+ // allowed by DNS to ensure backwards compatibility with Docker image
+ // names.
+ DomainRegexp = expression(
+ domainComponentRegexp,
+ optional(repeated(literal(`.`), domainComponentRegexp)),
+ optional(literal(`:`), match(`[0-9]+`)))
+
+ // TagRegexp matches valid tag names. From docker/docker:graph/tags.go.
+ TagRegexp = match(`[\w][\w.-]{0,127}`)
+
+ // anchoredTagRegexp matches valid tag names, anchored at the start and
+ // end of the matched string.
+ anchoredTagRegexp = anchored(TagRegexp)
+
+ // DigestRegexp matches valid digests.
+ DigestRegexp = match(`[A-Za-z][A-Za-z0-9]*(?:[-_+.][A-Za-z][A-Za-z0-9]*)*[:][[:xdigit:]]{32,}`)
+
+ // anchoredDigestRegexp matches valid digests, anchored at the start and
+ // end of the matched string.
+ anchoredDigestRegexp = anchored(DigestRegexp)
+
+ // NameRegexp is the format for the name component of references. The
+ // regexp has capturing groups for the domain and name part omitting
+ // the separating forward slash from either.
+ NameRegexp = expression(
+ optional(DomainRegexp, literal(`/`)),
+ nameComponentRegexp,
+ optional(repeated(literal(`/`), nameComponentRegexp)))
+
+ // anchoredNameRegexp is used to parse a name value, capturing the
+ // domain and trailing components.
+ anchoredNameRegexp = anchored(
+ optional(capture(DomainRegexp), literal(`/`)),
+ capture(nameComponentRegexp,
+ optional(repeated(literal(`/`), nameComponentRegexp))))
+
+ // ReferenceRegexp is the full supported format of a reference. The regexp
+ // is anchored and has capturing groups for name, tag, and digest
+ // components.
+ ReferenceRegexp = anchored(capture(NameRegexp),
+ optional(literal(":"), capture(TagRegexp)),
+ optional(literal("@"), capture(DigestRegexp)))
+
+ // IdentifierRegexp is the format for string identifier used as a
+ // content addressable identifier using sha256. These identifiers
+ // are like digests without the algorithm, since sha256 is used.
+ IdentifierRegexp = match(`([a-f0-9]{64})`)
+
+ // ShortIdentifierRegexp is the format used to represent a prefix
+ // of an identifier. A prefix may be used to match a sha256 identifier
+ // within a list of trusted identifiers.
+ ShortIdentifierRegexp = match(`([a-f0-9]{6,64})`)
+
+ // anchoredIdentifierRegexp is used to check or match an
+ // identifier value, anchored at start and end of string.
+ anchoredIdentifierRegexp = anchored(IdentifierRegexp)
+
+ // anchoredShortIdentifierRegexp is used to check if a value
+ // is a possible identifier prefix, anchored at start and end
+ // of string.
+ anchoredShortIdentifierRegexp = anchored(ShortIdentifierRegexp)
+)
+
+// match compiles the string to a regular expression.
+var match = regexp.MustCompile
+
+// literal compiles s into a literal regular expression, escaping any regexp
+// reserved characters.
+func literal(s string) *regexp.Regexp {
+ re := match(regexp.QuoteMeta(s))
+
+ if _, complete := re.LiteralPrefix(); !complete {
+ panic("must be a literal")
+ }
+
+ return re
+}
+
+// expression defines a full expression, where each regular expression must
+// follow the previous.
+func expression(res ...*regexp.Regexp) *regexp.Regexp {
+ var s string
+ for _, re := range res {
+ s += re.String()
+ }
+
+ return match(s)
+}
+
+// optional wraps the expression in a non-capturing group and makes the
+// production optional.
+func optional(res ...*regexp.Regexp) *regexp.Regexp {
+ return match(group(expression(res...)).String() + `?`)
+}
+
+// repeated wraps the regexp in a non-capturing group to get one or more
+// matches.
+func repeated(res ...*regexp.Regexp) *regexp.Regexp {
+ return match(group(expression(res...)).String() + `+`)
+}
+
+// group wraps the regexp in a non-capturing group.
+func group(res ...*regexp.Regexp) *regexp.Regexp {
+ return match(`(?:` + expression(res...).String() + `)`)
+}
+
+// capture wraps the expression in a capturing group.
+func capture(res ...*regexp.Regexp) *regexp.Regexp {
+ return match(`(` + expression(res...).String() + `)`)
+}
+
+// anchored anchors the regular expression by adding start and end delimiters.
+func anchored(res ...*regexp.Regexp) *regexp.Regexp {
+ return match(`^` + expression(res...).String() + `$`)
+}
diff --git a/vendor/github.com/docker/docker/AUTHORS b/vendor/github.com/docker/docker/AUTHORS
new file mode 100644
index 0000000..b314181
--- /dev/null
+++ b/vendor/github.com/docker/docker/AUTHORS
@@ -0,0 +1,2390 @@
+# File @generated by hack/generate-authors.sh. DO NOT EDIT.
+# This file lists all contributors to the repository.
+# See hack/generate-authors.sh to make modifications.
+
+Aanand Prasad
+Aaron Davidson
+Aaron Feng
+Aaron Hnatiw
+Aaron Huslage
+Aaron L. Xu
+Aaron Lehmann
+Aaron Welch
+Abel Muiño
+Abhijeet Kasurde
+Abhinandan Prativadi
+Abhinav Ajgaonkar
+Abhishek Chanda
+Abhishek Sharma
+Abin Shahab
+Abirdcfly
+Ada Mancini
+Adam Avilla
+Adam Dobrawy
+Adam Eijdenberg
+Adam Kunk
+Adam Miller
+Adam Mills
+Adam Pointer
+Adam Singer
+Adam Walz
+Adam Williams
+AdamKorcz
+Addam Hardy
+Aditi Rajagopal
+Aditya
+Adnan Khan
+Adolfo Ochagavía
+Adria Casas
+Adrian Moisey
+Adrian Mouat
+Adrian Oprea
+Adrien Folie
+Adrien Gallouët
+Ahmed Kamal
+Ahmet Alp Balkan
+Aidan Feldman
+Aidan Hobson Sayers
+AJ Bowen
+Ajey Charantimath
+ajneu
+Akash Gupta
+Akhil Mohan
+Akihiro Matsushima
+Akihiro Suda
+Akim Demaille
+Akira Koyasu
+Akshay Karle
+Akshay Moghe
+Al Tobey
+alambike
+Alan Hoyle
+Alan Scherger
+Alan Thompson
+Albert Callarisa
+Albert Zhang
+Albin Kerouanton
+Alec Benson
+Alejandro González Hevia
+Aleksa Sarai
+Aleksandr Chebotov
+Aleksandrs Fadins
+Alena Prokharchyk
+Alessandro Boch
+Alessio Biancalana
+Alex Chan
+Alex Chen
+Alex Coventry
+Alex Crawford
+Alex Ellis
+Alex Gaynor
+Alex Goodman
+Alex Nordlund
+Alex Olshansky
+Alex Samorukov
+Alex Stockinger
+Alex Warhawk
+Alexander Artemenko
+Alexander Boyd
+Alexander Larsson
+Alexander Midlash
+Alexander Morozov
+Alexander Polakov
+Alexander Shopov
+Alexandre Beslic
+Alexandre Garnier
+Alexandre González
+Alexandre Jomin
+Alexandru Sfirlogea
+Alexei Margasov
+Alexey Guskov
+Alexey Kotlyarov
+Alexey Shamrin
+Alexis Ries
+Alexis Thomas
+Alfred Landrum
+Ali Dehghani
+Alicia Lauerman
+Alihan Demir
+Allen Madsen
+Allen Sun
+almoehi
+Alvaro Saurin
+Alvin Deng
+Alvin Richards
+amangoel
+Amen Belayneh
+Ameya Gawde
+Amir Goldstein
+Amit Bakshi
+Amit Krishnan
+Amit Shukla
+Amr Gawish
+Amy Lindburg
+Anand Patil
+AnandkumarPatel
+Anatoly Borodin
+Anca Iordache
+Anchal Agrawal
+Anda Xu
+Anders Janmyr
+Andre Dublin <81dublin@gmail.com>
+Andre Granovsky
+Andrea Denisse Gómez
+Andrea Luzzardi
+Andrea Turli
+Andreas Elvers
+Andreas Köhler
+Andreas Savvides
+Andreas Tiefenthaler
+Andrei Gherzan
+Andrei Ushakov
+Andrei Vagin
+Andrew C. Bodine
+Andrew Clay Shafer
+Andrew Duckworth
+Andrew France
+Andrew Gerrand
+Andrew Guenther
+Andrew He
+Andrew Hsu
+Andrew Kim
+Andrew Kuklewicz
+Andrew Macgregor
+Andrew Macpherson
+Andrew Martin
+Andrew McDonnell
+Andrew Munsell
+Andrew Pennebaker
+Andrew Po
+Andrew Weiss
+Andrew Williams
+Andrews Medina
+Andrey Kolomentsev
+Andrey Petrov
+Andrey Stolbovsky
+André Martins
+Andy Chambers
+andy diller
+Andy Goldstein
+Andy Kipp
+Andy Lindeman
+Andy Rothfusz
+Andy Smith
+Andy Wilson
+Andy Zhang
+Anes Hasicic
+Angel Velazquez
+Anil Belur
+Anil Madhavapeddy
+Ankit Jain
+Ankush Agarwal
+Anonmily
+Anran Qiao
+Anshul Pundir
+Anthon van der Neut
+Anthony Baire
+Anthony Bishopric
+Anthony Dahanne
+Anthony Sottile
+Anton Löfgren
+Anton Nikitin
+Anton Polonskiy
+Anton Tiurin
+Antonio Murdaca
+Antonis Kalipetis
+Antony Messerli
+Anuj Bahuguna
+Anuj Varma
+Anusha Ragunathan
+Anyu Wang
+apocas
+Arash Deshmeh
+arcosx
+ArikaChen
+Arko Dasgupta
+Arnaud Lefebvre
+Arnaud Porterie
+Arnaud Rebillout
+Artem Khramov
+Arthur Barr
+Arthur Gautier
+Artur Meyster
+Arun Gupta
+Asad Saeeduddin
+Asbjørn Enge
+Austin Vazquez
+averagehuman
+Avi Das
+Avi Kivity
+Avi Miller
+Avi Vaid
+ayoshitake
+Azat Khuyiyakhmetov
+Bao Yonglei
+Bardia Keyoumarsi
+Barnaby Gray
+Barry Allard
+Bartłomiej Piotrowski
+Bastiaan Bakker
+Bastien Pascard
+bdevloed
+Bearice Ren
+Ben Bonnefoy
+Ben Firshman
+Ben Golub
+Ben Gould
+Ben Hall
+Ben Langfeld
+Ben Sargent
+Ben Severson
+Ben Toews
+Ben Wiklund
+Benjamin Atkin
+Benjamin Baker
+Benjamin Boudreau
+Benjamin Böhmke
+Benjamin Wang
+Benjamin Yolken
+Benny Ng
+Benoit Chesneau
+Bernerd Schaefer
+Bernhard M. Wiedemann
+Bert Goethals