*/

package constants

const (
	// CRISocketContainerd is the containerd CRI endpoint
	CRISocketContainerd = "unix:///var/run/containerd/containerd.sock"
	// CRISocketCRIO is the cri-o CRI endpoint
	CRISocketCRIO = "unix:///var/run/crio/crio.sock"
	// CRISocketDocker is the cri-dockerd CRI endpoint
	CRISocketDocker = "unix:///var/run/cri-dockerd.sock"

	// DefaultCRISocket defines the default CRI socket
	DefaultCRISocket = CRISocketContainerd

		if err != syscall.EINTR {
			break
		}
	}
	wantAccept4 := err != syscall.ENOSYS
	gotAccept4 := unix.SupportAccept4()
	if wantAccept4 != gotAccept4 {
		t.Fatalf("SupportAccept4, got %t; want %t", gotAccept4, wantAccept4)
	}

	// Test that the version returned by KernelVersion matches expectations.
	major, minor := unix.KernelVersion()
	t.Logf("Kernel version: %d.%d", major, minor)
	if runtime.GOOS == "illumos" {

    public static final Solaris SOLARIS = new Solaris();
    public static final Linux LINUX = new Linux();
    public static final FreeBSD FREE_BSD = new FreeBSD();
    public static final Unix UNIX = new Unix();
    private static OperatingSystem currentOs;
    private final String toStringValue;
    private final String osName;
    private final String osVersion;

    OperatingSystem() {

limitations under the License.
*/

package util

import (
	"fmt"
	"time"

	"golang.org/x/sys/unix"
)

// GetBootTime returns the time at which the machine was started, truncated to the nearest second
func GetBootTime() (time.Time, error) {
	currentTime := time.Now()
	var info unix.Sysinfo_t
	if err := unix.Sysinfo(&info); err != nil {
		return time.Time{}, fmt.Errorf("error getting system uptime: %s", err)
	}

limitations under the License.
*/

package util

import (
	"net/url"
	"path/filepath"
)

const (
	// unixProtocol is the network protocol of unix socket.
	unixProtocol = "unix"
)

// LocalEndpoint returns the full path to a unix socket at the given endpoint
func LocalEndpoint(path, file string) (string, error) {
	u := url.URL{
		Scheme: unixProtocol,
		Path:   path,
	}

limitations under the License.
*/

package copycerts

import "golang.org/x/sys/unix"

// on unix where umask may be in effect, clear umask so tests
// are not sensitive to the developer's system umask
func setNoUmask() {
	unix.Umask(0)

apiVersion: apiserver.config.k8s.io/v1
resources:
  - resources:
      - secrets
    providers:
      - kms:
          name: foo
          endpoint: unix:///tmp/testprovider.sock
          timeout:   15s
      - kms:
          name: bar
          endpoint: unix:///tmp/testprovider.sock

resources:
  - resources:
      - secrets
    providers:
      - kms:
          apiVersion: v3
          name: foo
          endpoint: unix:///tmp/testprovider.sock
          timeout:   15s
      - kms:
          name: bar
          endpoint: unix:///tmp/testprovider.sock

			opts: kubeletFlagsOpts{
				nodeRegOpts: &kubeadmapi.NodeRegistrationOptions{
					CRISocket: "unix:///var/run/containerd/containerd.sock",
					KubeletExtraArgs: []kubeadmapi.Arg{
						{Name: "hostname-override", Value: "override-name"},
					},
				},
			},
			expected: []kubeadmapi.Arg{
				{Name: "container-runtime-endpoint", Value: "unix:///var/run/containerd/containerd.sock"},
				{Name: "hostname-override", Value: "override-name"},

	if !testableNetwork("unix") {
		t.Skip("unix test")
	}

	handler := func(ls *localServer, ln Listener) {}
	for _, laddr := range []string{"", testUnixAddr(t)} {
		laddr := laddr
		taddr := testUnixAddr(t)
		ta, err := ResolveUnixAddr("unix", taddr)
		if err != nil {
			t.Fatal(err)
		}
		ln, err := ListenUnix("unix", ta)
		if err != nil {
			t.Fatal(err)
		}