// New creates the rkt container runtime which implements the container runtime interface.
// It will test if the rkt binary is in the $PATH, and whether we can get the
// version of it. If so, creates the rkt container runtime, otherwise returns an error.
func New(config *Config,
generator kubecontainer.RunContainerOptionsGenerator,
recorder record.EventRecorder,
containerRefManager *kubecontainer.RefManager,
livenessManager proberesults.Manager,
volumeGetter volumeGetter,
imageBackOff *util.Backoff,
serializeImagePulls bool,
) (*Runtime, error) {
// Create dbus connection.
systemd, err := newSystemd()
if err != nil {
return nil, fmt.Errorf("rkt: cannot create systemd interface: %v", err)
}
// TODO(yifan): Use secure connection.
apisvcConn, err := grpc.Dial(defaultRktAPIServiceAddr, grpc.WithInsecure())
if err != nil {
return nil, fmt.Errorf("rkt: cannot connect to rkt api service: %v", err)
}
rktBinAbsPath := config.Path
if rktBinAbsPath == "" {
// No default rkt path was set, so try to find one in $PATH.
var err error
rktBinAbsPath, err = exec.LookPath("rkt")
if err != nil {
return nil, fmt.Errorf("cannot find rkt binary: %v", err)
}
}
rkt := &Runtime{
systemd: systemd,
rktBinAbsPath: rktBinAbsPath,
apisvcConn: apisvcConn,
apisvc: rktapi.NewPublicAPIClient(apisvcConn),
config: config,
dockerKeyring: credentialprovider.NewDockerKeyring(),
containerRefManager: containerRefManager,
generator: generator,
recorder: recorder,
livenessManager: livenessManager,
volumeGetter: volumeGetter,
}
if serializeImagePulls {
rkt.imagePuller = kubecontainer.NewSerializedImagePuller(recorder, rkt, imageBackOff)
} else {
rkt.imagePuller = kubecontainer.NewImagePuller(recorder, rkt, imageBackOff)
}
if err := rkt.checkVersion(minimumRktBinVersion, recommendedRktBinVersion, minimumAppcVersion, minimumRktApiVersion, minimumSystemdVersion); err != nil {
// TODO(yifan): Latest go-systemd version have the ability to close the
// dbus connection. However the 'docker/libcontainer' package is using
// the older go-systemd version, so we can't update the go-systemd version.
rkt.apisvcConn.Close()
return nil, err
}
return rkt, nil
}
// New creates the hyper container runtime which implements the container runtime interface.
func New(generator kubecontainer.RunContainerOptionsGenerator,
recorder record.EventRecorder,
networkPlugin network.NetworkPlugin,
containerRefManager *kubecontainer.RefManager,
livenessManager proberesults.Manager,
volumeGetter volumeGetter,
kubeClient client.Interface,
imageBackOff *util.Backoff,
serializeImagePulls bool,
httpClient kubetypes.HttpGetter,
disableHyperInternalService bool,
containerLogsDir string,
os kubecontainer.OSInterface,
) (kubecontainer.Runtime, error) {
// check hyper has already installed
hyperBinAbsPath, err := exec.LookPath(hyperBinName)
if err != nil {
glog.Errorf("Hyper: can't find hyper binary")
return nil, fmt.Errorf("cannot find hyper binary: %v", err)
}
hyper := &runtime{
hyperBinAbsPath: hyperBinAbsPath,
dockerKeyring: credentialprovider.NewDockerKeyring(),
containerLogsDir: containerLogsDir,
containerRefManager: containerRefManager,
generator: generator,
livenessManager: livenessManager,
os: os,
recorder: recorder,
networkPlugin: networkPlugin,
volumeGetter: volumeGetter,
hyperClient: NewHyperClient(),
kubeClient: kubeClient,
disableHyperInternalService: disableHyperInternalService,
}
if serializeImagePulls {
hyper.imagePuller = kubecontainer.NewSerializedImagePuller(recorder, hyper, imageBackOff)
} else {
hyper.imagePuller = kubecontainer.NewImagePuller(recorder, hyper, imageBackOff)
}
version, err := hyper.hyperClient.Version()
if err != nil {
return nil, fmt.Errorf("cannot get hyper version: %v", err)
}
hyperVersion, err := parseVersion(version)
if err != nil {
return nil, fmt.Errorf("cannot get hyper version: %v", err)
}
hyper.version = hyperVersion
hyper.runner = lifecycle.NewHandlerRunner(httpClient, hyper, hyper)
return hyper, nil
}
// New creates the rkt container runtime which implements the container runtime interface.
// It will test if the rkt binary is in the $PATH, and whether we can get the
// version of it. If so, creates the rkt container runtime, otherwise returns an error.
func New(config *Config,
runtimeHelper kubecontainer.RuntimeHelper,
recorder record.EventRecorder,
containerRefManager *kubecontainer.RefManager,
livenessManager proberesults.Manager,
volumeGetter volumeGetter,
imageBackOff *util.Backoff,
serializeImagePulls bool,
) (*Runtime, error) {
// Create dbus connection.
systemd, err := newSystemd()
if err != nil {
return nil, fmt.Errorf("rkt: cannot create systemd interface: %v", err)
}
// TODO(yifan): Use secure connection.
apisvcConn, err := grpc.Dial(defaultRktAPIServiceAddr, grpc.WithInsecure())
if err != nil {
return nil, fmt.Errorf("rkt: cannot connect to rkt api service: %v", err)
}
rktBinAbsPath := config.Path
if rktBinAbsPath == "" {
// No default rkt path was set, so try to find one in $PATH.
var err error
rktBinAbsPath, err = exec.LookPath("rkt")
if err != nil {
return nil, fmt.Errorf("cannot find rkt binary: %v", err)
}
}
rkt := &Runtime{
systemd: systemd,
rktBinAbsPath: rktBinAbsPath,
apisvcConn: apisvcConn,
apisvc: rktapi.NewPublicAPIClient(apisvcConn),
config: config,
dockerKeyring: credentialprovider.NewDockerKeyring(),
containerRefManager: containerRefManager,
runtimeHelper: runtimeHelper,
recorder: recorder,
livenessManager: livenessManager,
volumeGetter: volumeGetter,
}
if serializeImagePulls {
rkt.imagePuller = kubecontainer.NewSerializedImagePuller(recorder, rkt, imageBackOff)
} else {
rkt.imagePuller = kubecontainer.NewImagePuller(recorder, rkt, imageBackOff)
}
if err := rkt.getVersions(); err != nil {
return nil, fmt.Errorf("rkt: error getting version info: %v", err)
}
return rkt, nil
}
// New creates the hyper container runtime which implements the container runtime interface.
func New(runtimeHelper kubecontainer.RuntimeHelper,
recorder record.EventRecorder,
networkPlugin network.NetworkPlugin,
containerRefManager *kubecontainer.RefManager,
livenessManager proberesults.Manager,
kubeClient clientset.Interface,
imageBackOff *flowcontrol.Backoff,
serializeImagePulls bool,
httpClient kubetypes.HttpGetter,
disableHyperInternalService bool,
containerLogsDir string,
os kubecontainer.OSInterface,
) (kubecontainer.Runtime, error) {
hyperClient, err := NewHyperClient()
if err != nil {
return nil, err
}
hyper := &runtime{
dockerKeyring: credentialprovider.NewDockerKeyring(),
containerLogsDir: containerLogsDir,
containerRefManager: containerRefManager,
runtimeHelper: runtimeHelper,
livenessManager: livenessManager,
os: os,
recorder: recorder,
networkPlugin: networkPlugin,
hyperClient: hyperClient,
kubeClient: kubeClient,
disableHyperInternalService: disableHyperInternalService,
}
if serializeImagePulls {
hyper.imagePuller = kubecontainer.NewSerializedImagePuller(recorder, hyper, imageBackOff)
} else {
hyper.imagePuller = kubecontainer.NewImagePuller(recorder, hyper, imageBackOff)
}
version, err := hyper.hyperClient.Version()
if err != nil {
return nil, fmt.Errorf("cannot get hyper version: %v", err)
}
hyperVersion, err := parseVersion(version)
if err != nil {
return nil, fmt.Errorf("cannot get hyper version: %v", err)
}
hyper.version = hyperVersion
hyper.runner = lifecycle.NewHandlerRunner(httpClient, hyper, hyper)
return hyper, nil
}
// New creates the hyper container runtime which implements the container runtime interface.
func New(generator kubecontainer.RunContainerOptionsGenerator,
recorder record.EventRecorder,
networkPlugin network.NetworkPlugin,
containerRefManager *kubecontainer.RefManager,
livenessManager proberesults.Manager,
volumeGetter volumeGetter,
kubeClient client.Interface,
imageBackOff *util.Backoff,
serializeImagePulls bool) (kubecontainer.Runtime, error) {
// check hyper has already installed
hyperBinAbsPath, err := exec.LookPath(hyperBinName)
if err != nil {
glog.Errorf("Hyper: can't find hyper binary")
return nil, fmt.Errorf("cannot find hyper binary: %v", err)
}
hyper := &runtime{
hyperBinAbsPath: hyperBinAbsPath,
dockerKeyring: credentialprovider.NewDockerKeyring(),
containerRefManager: containerRefManager,
generator: generator,
livenessManager: livenessManager,
recorder: recorder,
networkPlugin: networkPlugin,
volumeGetter: volumeGetter,
hyperClient: NewHyperClient(),
kubeClient: kubeClient,
}
if serializeImagePulls {
hyper.imagePuller = kubecontainer.NewSerializedImagePuller(recorder, hyper, imageBackOff)
} else {
hyper.imagePuller = kubecontainer.NewImagePuller(recorder, hyper, imageBackOff)
}
return hyper, nil
}
// New creates the rkt container runtime which implements the container runtime interface.
// It will test if the rkt binary is in the $PATH, and whether we can get the
// version of it. If so, creates the rkt container runtime, otherwise returns an error.
func New(config *Config,
generator kubecontainer.RunContainerOptionsGenerator,
recorder record.EventRecorder,
containerRefManager *kubecontainer.RefManager,
readinessManager *kubecontainer.ReadinessManager,
volumeGetter volumeGetter,
serializeImagePulls bool,
) (kubecontainer.Runtime, error) {
systemdVersion, err := getSystemdVersion()
if err != nil {
return nil, err
}
result, err := systemdVersion.Compare(systemdMinimumVersion)
if err != nil {
return nil, err
}
if result < 0 {
return nil, fmt.Errorf("rkt: systemd version is too old, requires at least %v", systemdMinimumVersion)
}
systemd, err := dbus.New()
if err != nil {
return nil, fmt.Errorf("cannot connect to dbus: %v", err)
}
rktBinAbsPath := config.Path
if rktBinAbsPath == "" {
// No default rkt path was set, so try to find one in $PATH.
var err error
rktBinAbsPath, err = exec.LookPath("rkt")
if err != nil {
return nil, fmt.Errorf("cannot find rkt binary: %v", err)
}
}
rkt := &runtime{
systemd: systemd,
rktBinAbsPath: rktBinAbsPath,
config: config,
dockerKeyring: credentialprovider.NewDockerKeyring(),
containerRefManager: containerRefManager,
generator: generator,
recorder: recorder,
readinessManager: readinessManager,
volumeGetter: volumeGetter,
}
rkt.prober = prober.New(rkt, readinessManager, containerRefManager, recorder)
if serializeImagePulls {
rkt.imagePuller = kubecontainer.NewSerializedImagePuller(recorder, rkt)
} else {
rkt.imagePuller = kubecontainer.NewImagePuller(recorder, rkt)
}
// Test the rkt version.
version, err := rkt.Version()
if err != nil {
return nil, err
}
result, err = version.Compare(rktMinimumVersion)
if err != nil {
return nil, err
}
if result < 0 {
return nil, fmt.Errorf("rkt: Version is too old, requires at least %v", rktMinimumVersion)
}
return rkt, nil
}
// New creates the rkt container runtime which implements the container runtime interface.
// It will test if the rkt binary is in the $PATH, and whether we can get the
// version of it. If so, creates the rkt container runtime, otherwise returns an error.
func New(config *Config,
generator kubecontainer.RunContainerOptionsGenerator,
recorder record.EventRecorder,
containerRefManager *kubecontainer.RefManager,
livenessManager proberesults.Manager,
volumeGetter volumeGetter,
imageBackOff *util.Backoff,
serializeImagePulls bool,
) (*Runtime, error) {
systemdVersion, err := getSystemdVersion()
if err != nil {
return nil, err
}
result, err := systemdVersion.Compare(systemdMinimumVersion)
if err != nil {
return nil, err
}
if result < 0 {
return nil, fmt.Errorf("rkt: systemd version is too old, requires at least %v", systemdMinimumVersion)
}
systemd, err := dbus.New()
if err != nil {
return nil, fmt.Errorf("cannot connect to dbus: %v", err)
}
rktBinAbsPath := config.Path
if rktBinAbsPath == "" {
// No default rkt path was set, so try to find one in $PATH.
var err error
rktBinAbsPath, err = exec.LookPath("rkt")
if err != nil {
return nil, fmt.Errorf("cannot find rkt binary: %v", err)
}
}
rkt := &Runtime{
systemd: systemd,
rktBinAbsPath: rktBinAbsPath,
config: config,
dockerKeyring: credentialprovider.NewDockerKeyring(),
containerRefManager: containerRefManager,
generator: generator,
recorder: recorder,
livenessManager: livenessManager,
volumeGetter: volumeGetter,
}
if serializeImagePulls {
rkt.imagePuller = kubecontainer.NewSerializedImagePuller(recorder, rkt, imageBackOff)
} else {
rkt.imagePuller = kubecontainer.NewImagePuller(recorder, rkt, imageBackOff)
}
// Test the rkt version.
version, err := rkt.Version()
if err != nil {
return nil, err
}
result, err = version.Compare(minimumRktVersion)
if err != nil {
return nil, err
}
if result < 0 {
return nil, fmt.Errorf("rkt: version is too old, requires at least %v", minimumRktVersion)
}
result, err = version.Compare(recommendRktVersion)
if err != nil {
return nil, err
}
if result != 0 {
// TODO(yifan): Record an event to expose the information.
glog.Warningf("rkt: current version %q is not recommended (recommended version %q)", version, recommendRktVersion)
}
return rkt, nil
}