mirror of
https://github.com/netbirdio/netbird.git
synced 2026-09-12 17:59:06 +02:00
riccardom
c71fd1d841
The previous commit made a peer with no destination — no MDM override, no URL
named by the caller, nothing published by its management server — refuse to
upload and keep the bundle local unless it was enrolled with NetBird's cloud.
That closed the reported data-boundary concern, but it broke the default for
everyone who uploads a bundle as part of their day: a self-hosted user opening
a support ticket got a refusal where the command used to work.
Product decision (NetBird's, not the reporter's): the knob to keep bundles
inside your own infrastructure is what this branch provides, and it is enough.
The default stays the service NetBird runs, self-hosted included. An admin who
needs the bundles to stay in-house configures the destination; until then the
everyday flow keeps working.
So ResolveUploadURL drops the cloud check, the sentinel error and the
managementURL argument, and never fails:
MDM > explicitly named URL > published by management > NetBird's service
Nothing observable changes for a deployment that configures nothing, which also
removes two edge cases the fail-closed default had: a peer still enrolled on the
legacy api.wiretrustee.com host would have been classified self-hosted and
refused, and an upgrade would have silently stopped uploads for self-hosted
deployments relying on them. The privilege gate is unaffected — a host other
than the default one still requires a privileged caller, so pointing the CLI
somewhere other than what management published needs root.
84 lines
2.2 KiB
Go
84 lines
2.2 KiB
Go
package jobexec
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"time"
|
|
|
|
log "github.com/sirupsen/logrus"
|
|
|
|
"github.com/netbirdio/netbird/client/internal/debug"
|
|
)
|
|
|
|
const (
|
|
MaxBundleWaitTime = 60 * time.Minute // maximum wait time for bundle generation (1 hour)
|
|
)
|
|
|
|
var (
|
|
ErrJobNotImplemented = errors.New("job not implemented")
|
|
)
|
|
|
|
type Executor struct {
|
|
}
|
|
|
|
func NewExecutor() *Executor {
|
|
return &Executor{}
|
|
}
|
|
|
|
// BundleJob generates a debug bundle for a remote job and uploads it to
|
|
// uploadURL, returning the key the management server hands back to whoever asked.
|
|
// The caller resolves uploadURL (see debug.ResolveUploadURL), which never yields
|
|
// an empty one, so there is no fallback destination to pick locally.
|
|
func (e *Executor) BundleJob(ctx context.Context, debugBundleDependencies debug.GeneratorDependencies, params debug.BundleConfig, waitForDuration time.Duration, mgmURL, uploadURL string) (string, error) {
|
|
if uploadURL == "" {
|
|
return "", errors.New("no debug bundle upload destination resolved")
|
|
}
|
|
|
|
if waitForDuration > MaxBundleWaitTime {
|
|
log.Warnf("bundle wait time %v exceeds maximum %v, capping to maximum", waitForDuration, MaxBundleWaitTime)
|
|
waitForDuration = MaxBundleWaitTime
|
|
}
|
|
|
|
if waitForDuration > 0 {
|
|
if err := waitFor(ctx, waitForDuration); err != nil {
|
|
return "", err
|
|
}
|
|
}
|
|
|
|
log.Infof("execute debug bundle generation")
|
|
|
|
bundleGenerator := debug.NewBundleGenerator(debugBundleDependencies, params)
|
|
|
|
path, err := bundleGenerator.Generate()
|
|
if err != nil {
|
|
return "", fmt.Errorf("generate debug bundle: %w", err)
|
|
}
|
|
defer func() {
|
|
if err := os.Remove(path); err != nil {
|
|
log.Errorf("failed to remove debug bundle file: %v", err)
|
|
}
|
|
}()
|
|
|
|
key, err := debug.UploadDebugBundle(ctx, uploadURL, mgmURL, path, false)
|
|
if err != nil {
|
|
log.Errorf("failed to upload debug bundle: %v", err)
|
|
return "", fmt.Errorf("upload debug bundle: %w", err)
|
|
}
|
|
|
|
log.Infof("debug bundle has been generated successfully")
|
|
return key, nil
|
|
}
|
|
|
|
func waitFor(ctx context.Context, duration time.Duration) error {
|
|
log.Infof("wait for %v minutes before executing debug bundle", duration.Minutes())
|
|
select {
|
|
case <-time.After(duration):
|
|
return nil
|
|
case <-ctx.Done():
|
|
log.Infof("wait cancelled: %v", ctx.Err())
|
|
return ctx.Err()
|
|
}
|
|
}
|