move initsystem to kubeadm

Signed-off-by: Yassine TIJANI <ytijani@vmware.com>

cmd/kubeadm/.import-restrictions

@@ -78,7 +78,6 @@
 				"k8s.io/kubernetes/pkg/util/conntrack",
 				"k8s.io/kubernetes/pkg/util/dbus",
 				"k8s.io/kubernetes/pkg/util/hash",
-				"k8s.io/kubernetes/pkg/util/initsystem",
 				"k8s.io/kubernetes/pkg/util/ipset",
 				"k8s.io/kubernetes/pkg/util/iptables",
 				"k8s.io/kubernetes/pkg/util/ipvs",

cmd/kubeadm/app/cmd/phases/reset/BUILD

@@ -20,9 +20,9 @@ go_library(
         "//cmd/kubeadm/app/phases/etcd:go_default_library",
         "//cmd/kubeadm/app/phases/uploadconfig:go_default_library",
         "//cmd/kubeadm/app/preflight:go_default_library",
+        "//cmd/kubeadm/app/util/initsystem:go_default_library",
         "//cmd/kubeadm/app/util/runtime:go_default_library",
         "//cmd/kubeadm/app/util/staticpod:go_default_library",
-        "//pkg/util/initsystem:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/util/sets:go_default_library",
         "//staging/src/k8s.io/client-go/kubernetes:go_default_library",
         "//vendor/k8s.io/klog:go_default_library",

cmd/kubeadm/app/cmd/phases/reset/cleanupnode.go

@@ -28,8 +28,8 @@ import (
 	"k8s.io/kubernetes/cmd/kubeadm/app/cmd/options"
 	"k8s.io/kubernetes/cmd/kubeadm/app/cmd/phases/workflow"
 	kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
+	"k8s.io/kubernetes/cmd/kubeadm/app/util/initsystem"
 	utilruntime "k8s.io/kubernetes/cmd/kubeadm/app/util/runtime"
-	"k8s.io/kubernetes/pkg/util/initsystem"
 	utilsexec "k8s.io/utils/exec"
 )
 

cmd/kubeadm/app/phases/kubelet/BUILD

@@ -17,8 +17,8 @@ go_library(
         "//cmd/kubeadm/app/images:go_default_library",
         "//cmd/kubeadm/app/util:go_default_library",
         "//cmd/kubeadm/app/util/apiclient:go_default_library",
+        "//cmd/kubeadm/app/util/initsystem:go_default_library",
         "//pkg/kubelet/apis/config:go_default_library",
-        "//pkg/util/initsystem:go_default_library",
         "//pkg/util/node:go_default_library",
         "//pkg/util/procfs:go_default_library",
         "//staging/src/k8s.io/api/core/v1:go_default_library",

cmd/kubeadm/app/phases/kubelet/kubelet.go

@@ -19,7 +19,7 @@ package kubelet
 import (
 	"fmt"
 
-	"k8s.io/kubernetes/pkg/util/initsystem"
+	"k8s.io/kubernetes/cmd/kubeadm/app/util/initsystem"
 )
 
 // TryStartKubelet attempts to bring up kubelet service

cmd/kubeadm/app/preflight/BUILD

@@ -21,11 +21,11 @@ go_library(
         "//cmd/kubeadm/app/apis/kubeadm:go_default_library",
         "//cmd/kubeadm/app/constants:go_default_library",
         "//cmd/kubeadm/app/images:go_default_library",
+        "//cmd/kubeadm/app/util/initsystem:go_default_library",
         "//cmd/kubeadm/app/util/runtime:go_default_library",
         "//cmd/kubeadm/app/util/system:go_default_library",
         "//pkg/master/ports:go_default_library",
         "//pkg/registry/core/service/ipallocator:go_default_library",
-        "//pkg/util/initsystem:go_default_library",
         "//pkg/util/ipvs:go_default_library",
         "//pkg/version:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/util/net:go_default_library",

cmd/kubeadm/app/preflight/checks.go

@@ -44,11 +44,11 @@ import (
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
 	kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
 	"k8s.io/kubernetes/cmd/kubeadm/app/images"
+	"k8s.io/kubernetes/cmd/kubeadm/app/util/initsystem"
 	utilruntime "k8s.io/kubernetes/cmd/kubeadm/app/util/runtime"
 	"k8s.io/kubernetes/cmd/kubeadm/app/util/system"
 	"k8s.io/kubernetes/pkg/master/ports"
 	"k8s.io/kubernetes/pkg/registry/core/service/ipallocator"
-	"k8s.io/kubernetes/pkg/util/initsystem"
 	ipvsutil "k8s.io/kubernetes/pkg/util/ipvs"
 	kubeadmversion "k8s.io/kubernetes/pkg/version"
 	utilsexec "k8s.io/utils/exec"

cmd/kubeadm/app/util/BUILD

@@ -84,6 +84,7 @@ filegroup(
         "//cmd/kubeadm/app/util/crypto:all-srcs",
         "//cmd/kubeadm/app/util/dryrun:all-srcs",
         "//cmd/kubeadm/app/util/etcd:all-srcs",
+        "//cmd/kubeadm/app/util/initsystem:all-srcs",
         "//cmd/kubeadm/app/util/kubeconfig:all-srcs",
         "//cmd/kubeadm/app/util/pkiutil:all-srcs",
         "//cmd/kubeadm/app/util/pubkeypin:all-srcs",

cmd/kubeadm/app/util/initsystem/BUILD

@@ -0,0 +1,36 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "initsystem.go",
+        "initsystem_unix.go",
+        "initsystem_windows.go",
+    ],
+    importpath = "k8s.io/kubernetes/cmd/kubeadm/app/util/initsystem",
+    deps = select({
+        "@io_bazel_rules_go//go/platform:windows": [
+            "//vendor/golang.org/x/sys/windows/svc:go_default_library",
+            "//vendor/golang.org/x/sys/windows/svc/mgr:go_default_library",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

cmd/kubeadm/app/util/initsystem/initsystem.go

@@ -0,0 +1,41 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package initsystem
+
+// InitSystem is the interface that describe behaviors of an init system
+type InitSystem interface {
+	// return a string describing how to enable a service
+	EnableCommand(service string) string
+
+	// ServiceStart tries to start a specific service
+	ServiceStart(service string) error
+
+	// ServiceStop tries to stop a specific service
+	ServiceStop(service string) error
+
+	// ServiceRestart tries to reload the environment and restart the specific service
+	ServiceRestart(service string) error
+
+	// ServiceExists ensures the service is defined for this init system.
+	ServiceExists(service string) bool
+
+	// ServiceIsEnabled ensures the service is enabled to start on each boot.
+	ServiceIsEnabled(service string) bool
+
+	// ServiceIsActive ensures the service is running, or attempting to run. (crash looping in the case of kubelet)
+	ServiceIsActive(service string) bool
+}

cmd/kubeadm/app/util/initsystem/initsystem_unix.go

@@ -0,0 +1,178 @@
+// +build !windows
+
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package initsystem
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+)
+
+// OpenRCInitSystem defines openrc
+type OpenRCInitSystem struct{}
+
+// ServiceStart tries to start a specific service
+func (openrc OpenRCInitSystem) ServiceStart(service string) error {
+	args := []string{service, "start"}
+	return exec.Command("rc-service", args...).Run()
+}
+
+// ServiceStop tries to stop a specific service
+func (openrc OpenRCInitSystem) ServiceStop(service string) error {
+	args := []string{service, "stop"}
+	return exec.Command("rc-service", args...).Run()
+}
+
+// ServiceRestart tries to reload the environment and restart the specific service
+func (openrc OpenRCInitSystem) ServiceRestart(service string) error {
+	args := []string{service, "restart"}
+	return exec.Command("rc-service", args...).Run()
+}
+
+// ServiceExists ensures the service is defined for this init system.
+// openrc writes to stderr if a service is not found or not enabled
+// this is in contrast to systemd which only writes to stdout.
+// Hence, we use the Combinedoutput, and ignore the error.
+func (openrc OpenRCInitSystem) ServiceExists(service string) bool {
+	args := []string{service, "status"}
+	outBytes, _ := exec.Command("rc-service", args...).CombinedOutput()
+	if strings.Contains(string(outBytes), "does not exist") {
+		return false
+	}
+	return true
+}
+
+// ServiceIsEnabled ensures the service is enabled to start on each boot.
+func (openrc OpenRCInitSystem) ServiceIsEnabled(service string) bool {
+	args := []string{"show", "default"}
+	outBytes, _ := exec.Command("rc-update", args...).Output()
+	if strings.Contains(string(outBytes), service) {
+		return true
+	}
+	return false
+}
+
+// ServiceIsActive ensures the service is running, or attempting to run. (crash looping in the case of kubelet)
+func (openrc OpenRCInitSystem) ServiceIsActive(service string) bool {
+	args := []string{service, "status"}
+	outBytes, _ := exec.Command("rc-service", args...).Output()
+	if strings.Contains(string(outBytes), "stopped") {
+		return false
+	}
+	return true
+}
+
+// EnableCommand return a string describing how to enable a service
+func (openrc OpenRCInitSystem) EnableCommand(service string) string {
+	return fmt.Sprintf("rc-update add %s default", service)
+}
+
+// SystemdInitSystem defines systemd
+type SystemdInitSystem struct{}
+
+// EnableCommand return a string describing how to enable a service
+func (sysd SystemdInitSystem) EnableCommand(service string) string {
+	return fmt.Sprintf("systemctl enable %s.service", service)
+}
+
+// reloadSystemd reloeads the systemd daemon
+func (sysd SystemdInitSystem) reloadSystemd() error {
+	if err := exec.Command("systemctl", "daemon-reload").Run(); err != nil {
+		return fmt.Errorf("failed to reload systemd: %v", err)
+	}
+	return nil
+}
+
+// ServiceStart tries to start a specific service
+func (sysd SystemdInitSystem) ServiceStart(service string) error {
+	// Before we try to start any service, make sure that systemd is ready
+	if err := sysd.reloadSystemd(); err != nil {
+		return err
+	}
+	args := []string{"start", service}
+	return exec.Command("systemctl", args...).Run()
+}
+
+// ServiceRestart tries to reload the environment and restart the specific service
+func (sysd SystemdInitSystem) ServiceRestart(service string) error {
+	// Before we try to restart any service, make sure that systemd is ready
+	if err := sysd.reloadSystemd(); err != nil {
+		return err
+	}
+	args := []string{"restart", service}
+	return exec.Command("systemctl", args...).Run()
+}
+
+// ServiceStop tries to stop a specific service
+func (sysd SystemdInitSystem) ServiceStop(service string) error {
+	args := []string{"stop", service}
+	return exec.Command("systemctl", args...).Run()
+}
+
+// ServiceExists ensures the service is defined for this init system.
+func (sysd SystemdInitSystem) ServiceExists(service string) bool {
+	args := []string{"status", service}
+	outBytes, _ := exec.Command("systemctl", args...).Output()
+	output := string(outBytes)
+	if strings.Contains(output, "Loaded: not-found") {
+		return false
+	}
+	return true
+}
+
+// ServiceIsEnabled ensures the service is enabled to start on each boot.
+func (sysd SystemdInitSystem) ServiceIsEnabled(service string) bool {
+	args := []string{"is-enabled", service}
+	err := exec.Command("systemctl", args...).Run()
+	if err != nil {
+		return false
+	}
+	return true
+}
+
+// ServiceIsActive will check is the service is "active". In the case of
+// crash looping services (kubelet in our case) status will return as
+// "activating", so we will consider this active as well.
+func (sysd SystemdInitSystem) ServiceIsActive(service string) bool {
+	args := []string{"is-active", service}
+	// Ignoring error here, command returns non-0 if in "activating" status:
+	outBytes, _ := exec.Command("systemctl", args...).Output()
+	output := strings.TrimSpace(string(outBytes))
+	if output == "active" || output == "activating" {
+		return true
+	}
+	return false
+}
+
+// GetInitSystem returns an InitSystem for the current system, or nil
+// if we cannot detect a supported init system.
+// This indicates we will skip init system checks, not an error.
+func GetInitSystem() (InitSystem, error) {
+	// Assume existence of systemctl in path implies this is a systemd system:
+	_, err := exec.LookPath("systemctl")
+	if err == nil {
+		return &SystemdInitSystem{}, nil
+	}
+	_, err = exec.LookPath("openrc")
+	if err == nil {
+		return &OpenRCInitSystem{}, nil
+	}
+
+	return nil, fmt.Errorf("no supported init system detected, skipping checking for services")
+}

cmd/kubeadm/app/util/initsystem/initsystem_windows.go

@@ -0,0 +1,245 @@
+// +build windows
+
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package initsystem
+
+import (
+	"fmt"
+	"time"
+
+	"golang.org/x/sys/windows/svc"
+	"golang.org/x/sys/windows/svc/mgr"
+)
+
+// WindowsInitSystem is the windows implementation of InitSystem
+type WindowsInitSystem struct{}
+
+// EnableCommand return a string describing how to enable a service
+func (sysd WindowsInitSystem) EnableCommand(service string) string {
+	return fmt.Sprintf("Set-Service '%s' -StartupType Automatic", service)
+}
+
+// ServiceStart tries to start a specific service
+// Following Windows documentation: https://docs.microsoft.com/en-us/windows/desktop/Services/starting-a-service
+func (sysd WindowsInitSystem) ServiceStart(service string) error {
+	m, err := mgr.Connect()
+	if err != nil {
+		return err
+	}
+	defer m.Disconnect()
+
+	s, err := m.OpenService(service)
+	if err != nil {
+		return fmt.Errorf("could not access service %s: %v", service, err)
+	}
+	defer s.Close()
+
+	// Check if service is already started
+	status, err := s.Query()
+	if err != nil {
+		return fmt.Errorf("could not query service %s: %v", service, err)
+	}
+
+	if status.State != svc.Stopped && status.State != svc.StopPending {
+		return nil
+	}
+
+	timeout := time.Now().Add(10 * time.Second)
+	for status.State != svc.Stopped {
+		if timeout.Before(time.Now()) {
+			return fmt.Errorf("timeout waiting for %s service to stop", service)
+		}
+		time.Sleep(300 * time.Millisecond)
+		status, err = s.Query()
+		if err != nil {
+			return fmt.Errorf("could not retrieve %s service status: %v", service, err)
+		}
+	}
+
+	// Start the service
+	err = s.Start("is", "manual-started")
+	if err != nil {
+		return fmt.Errorf("could not start service %s: %v", service, err)
+	}
+
+	// Check that the start was successful
+	status, err = s.Query()
+	if err != nil {
+		return fmt.Errorf("could not query service %s: %v", service, err)
+	}
+	timeout = time.Now().Add(10 * time.Second)
+	for status.State != svc.Running {
+		if timeout.Before(time.Now()) {
+			return fmt.Errorf("timeout waiting for %s service to start", service)
+		}
+		time.Sleep(300 * time.Millisecond)
+		status, err = s.Query()
+		if err != nil {
+			return fmt.Errorf("could not retrieve %s service status: %v", service, err)
+		}
+	}
+	return nil
+}
+
+// ServiceRestart tries to reload the environment and restart the specific service
+func (sysd WindowsInitSystem) ServiceRestart(service string) error {
+	if err := sysd.ServiceStop(service); err != nil {
+		return fmt.Errorf("couldn't stop service %s: %v", service, err)
+	}
+	if err := sysd.ServiceStart(service); err != nil {
+		return fmt.Errorf("couldn't start service %s: %v", service, err)
+	}
+
+	return nil
+}
+
+// ServiceStop tries to stop a specific service
+// Following Windows documentation: https://docs.microsoft.com/en-us/windows/desktop/Services/stopping-a-service
+func (sysd WindowsInitSystem) ServiceStop(service string) error {
+	m, err := mgr.Connect()
+	if err != nil {
+		return err
+	}
+	defer m.Disconnect()
+
+	s, err := m.OpenService(service)
+	if err != nil {
+		return fmt.Errorf("could not access service %s: %v", service, err)
+	}
+	defer s.Close()
+
+	// Check if service is already stopped
+	status, err := s.Query()
+	if err != nil {
+		return fmt.Errorf("could not query service %s: %v", service, err)
+	}
+
+	if status.State == svc.Stopped {
+		return nil
+	}
+
+	// If StopPending, check that service eventually stops
+	if status.State == svc.StopPending {
+		timeout := time.Now().Add(10 * time.Second)
+		for status.State != svc.Stopped {
+			if timeout.Before(time.Now()) {
+				return fmt.Errorf("timeout waiting for %s service to stop", service)
+			}
+			time.Sleep(300 * time.Millisecond)
+			status, err = s.Query()
+			if err != nil {
+				return fmt.Errorf("could not retrieve %s service status: %v", service, err)
+			}
+		}
+		return nil
+	}
+
+	// Stop the service
+	status, err = s.Control(svc.Stop)
+	if err != nil {
+		return fmt.Errorf("could not stop service %s: %v", service, err)
+	}
+
+	// Check that the stop was successful
+	status, err = s.Query()
+	if err != nil {
+		return fmt.Errorf("could not query service %s: %v", service, err)
+	}
+	timeout := time.Now().Add(10 * time.Second)
+	for status.State != svc.Stopped {
+		if timeout.Before(time.Now()) {
+			return fmt.Errorf("timeout waiting for %s service to stop", service)
+		}
+		time.Sleep(300 * time.Millisecond)
+		status, err = s.Query()
+		if err != nil {
+			return fmt.Errorf("could not retrieve %s service status: %v", service, err)
+		}
+	}
+	return nil
+}
+
+// ServiceExists ensures the service is defined for this init system.
+func (sysd WindowsInitSystem) ServiceExists(service string) bool {
+	m, err := mgr.Connect()
+	if err != nil {
+		return false
+	}
+	defer m.Disconnect()
+	s, err := m.OpenService(service)
+	if err != nil {
+		return false
+	}
+	defer s.Close()
+
+	return true
+}
+
+// ServiceIsEnabled ensures the service is enabled to start on each boot.
+func (sysd WindowsInitSystem) ServiceIsEnabled(service string) bool {
+	m, err := mgr.Connect()
+	if err != nil {
+		return false
+	}
+	defer m.Disconnect()
+
+	s, err := m.OpenService(service)
+	if err != nil {
+		return false
+	}
+	defer s.Close()
+
+	c, err := s.Config()
+	if err != nil {
+		return false
+	}
+
+	return c.StartType != mgr.StartDisabled
+}
+
+// ServiceIsActive ensures the service is running, or attempting to run. (crash looping in the case of kubelet)
+func (sysd WindowsInitSystem) ServiceIsActive(service string) bool {
+	m, err := mgr.Connect()
+	if err != nil {
+		return false
+	}
+	defer m.Disconnect()
+	s, err := m.OpenService(service)
+	if err != nil {
+		return false
+	}
+	defer s.Close()
+
+	status, err := s.Query()
+	if err != nil {
+		return false
+	}
+	return status.State == svc.Running
+}
+
+// GetInitSystem returns an InitSystem for the current system, or nil
+// if we cannot detect a supported init system.
+// This indicates we will skip init system checks, not an error.
+func GetInitSystem() (InitSystem, error) {
+	m, err := mgr.Connect()
+	if err != nil {
+		return nil, fmt.Errorf("no supported init system detected: %v", err)
+	}
+	defer m.Disconnect()
+	return &WindowsInitSystem{}, nil
+}