1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
|
package singleprocess
import (
"context"
"sync"
"github.com/hashicorp/go-hclog"
"gorm.io/gorm"
"github.com/hashicorp/vagrant/internal/server/proto/vagrant_server"
"github.com/hashicorp/vagrant/internal/server/singleprocess/state"
"github.com/hashicorp/vagrant/internal/serverconfig"
)
// service implements the gRPC service for the server.
type service struct {
// state is the state management interface that provides functions for
// safely mutating server state.
state *state.State
// id is our unique server ID.
id string
// bgCtx is used for background tasks within the service. This is
// cancelled when Close is called.
bgCtx context.Context
bgCtxCancel context.CancelFunc
// bgWg is incremented for every background goroutine that the
// service starts up. When Close is called, we wait on this to ensure
// that we fully shut down before returning.
bgWg sync.WaitGroup
vagrant_server.UnimplementedVagrantServer
}
// New returns a Vagrant server implementation that uses BoltDB plus
// in-memory locks to operate safely.
func New(opts ...Option) (vagrant_server.VagrantServer, error) {
var s service
var cfg config
for _, opt := range opts {
if err := opt(&s, &cfg); err != nil {
return nil, err
}
}
log := cfg.log
if log == nil {
log = hclog.L()
}
// Initialize our state
st, err := state.New(log, cfg.db)
if err != nil {
log.Trace("state initialization failed", "error", err)
return nil, err
}
s.state = st
// Setup the background context that is used for internal tasks
s.bgCtx, s.bgCtxCancel = context.WithCancel(context.Background())
// Start out state pruning background goroutine. This calls
// Prune on the state every 10 minutes.
s.bgWg.Add(1)
go s.runPrune(s.bgCtx, &s.bgWg, log.Named("prune"))
return &s, nil
}
type config struct {
db *gorm.DB
serverConfig *serverconfig.Config
log hclog.Logger
}
type Option func(*service, *config) error
// WithDB sets the Bolt DB for use with the server.
func WithDB(db *gorm.DB) Option {
return func(s *service, cfg *config) error {
cfg.db = db
return nil
}
}
// WithConfig sets the server config in use with this server.
func WithConfig(scfg *serverconfig.Config) Option {
return func(s *service, cfg *config) error {
cfg.serverConfig = scfg
return nil
}
}
// WithLogger sets the logger for use with the server.
func WithLogger(log hclog.Logger) Option {
return func(s *service, cfg *config) error {
cfg.log = log
return nil
}
}
var _ vagrant_server.VagrantServer = (*service)(nil)
|
