diff --git a/.gitignore b/.gitignore index b94f87b..086c2cd 100644 --- a/.gitignore +++ b/.gitignore @@ -7,6 +7,5 @@ _proto/*.pb.go bin/ rootfs/tiller rootfs/rudder -vendor/ *.exe .idea/ diff --git a/vendor/github.com/docker/docker/pkg/term/tc.go b/vendor/github.com/docker/docker/pkg/term/tc.go index 6d2dfd3..12fe4c9 100644 --- a/vendor/github.com/docker/docker/pkg/term/tc.go +++ b/vendor/github.com/docker/docker/pkg/term/tc.go @@ -1,4 +1,5 @@ // +build !windows +// +build !aix // +build !solaris !cgo package term diff --git a/vendor/github.com/docker/docker/pkg/term/tc_aix_cgo.go b/vendor/github.com/docker/docker/pkg/term/tc_aix_cgo.go new file mode 100644 index 0000000..3531415 --- /dev/null +++ b/vendor/github.com/docker/docker/pkg/term/tc_aix_cgo.go @@ -0,0 +1,53 @@ +// +build aix + +package term + +import ( + "syscall" + "unsafe" +) + +// #include +import "C" + +// Termios is the Unix API for terminal I/O. +// It is passthgrouh for syscall.Termios in order to make it portable with +// other platforms where it is not available or handled differently. +type Termios syscall.Termios + +// MakeRaw put the terminal connected to the given file descriptor into raw +// mode and returns the previous state of the terminal so that it can be +// restored. +func MakeRaw(fd uintptr) (*State, error) { + var oldState State + if err := tcget(fd, &oldState.termios); err != 0 { + return nil, err + } + + newState := oldState.termios + + C.cfmakeraw((*C.struct_termios)(unsafe.Pointer(&newState))) + newState.Cc[C.VMIN] = 1 + newState.Cc[C.VTIME] = 0 + + if err := tcset(fd, &newState); err != 0 { + return nil, err + } + return &oldState, nil +} + +func tcget(fd uintptr, p *Termios) syscall.Errno { + ret, err := C.tcgetattr(C.int(fd), (*C.struct_termios)(unsafe.Pointer(p))) + if ret != 0 { + return err.(syscall.Errno) + } + return 0 +} + +func tcset(fd uintptr, p *Termios) syscall.Errno { + ret, err := C.tcsetattr(C.int(fd), C.TCSANOW, (*C.struct_termios)(unsafe.Pointer(p))) + if ret != 0 { + return err.(syscall.Errno) + } + return 0 +} diff --git a/vendor/github.com/docker/docker/pkg/term/term.go b/vendor/github.com/docker/docker/pkg/term/term.go index 4f59d8d..816f8d7 100644 --- a/vendor/github.com/docker/docker/pkg/term/term.go +++ b/vendor/github.com/docker/docker/pkg/term/term.go @@ -10,8 +10,7 @@ import ( "io" "os" "os/signal" - - "golang.org/x/sys/unix" + "syscall" ) var ( @@ -80,7 +79,7 @@ func SaveState(fd uintptr) (*State, error) { // descriptor, with echo disabled. func DisableEcho(fd uintptr, state *State) error { newState := state.termios - newState.Lflag &^= unix.ECHO + newState.Lflag &^= syscall.ECHO if err := tcset(fd, &newState); err != 0 { return err diff --git a/vendor/github.com/docker/docker/pkg/term/winsize.go b/vendor/github.com/docker/docker/pkg/term/winsize.go index f58367f..736da69 100644 --- a/vendor/github.com/docker/docker/pkg/term/winsize.go +++ b/vendor/github.com/docker/docker/pkg/term/winsize.go @@ -1,4 +1,4 @@ -// +build !solaris,!windows +// +build !solaris,!windows,!aix package term diff --git a/vendor/github.com/docker/docker/pkg/term/winsize_aix_cgo.go b/vendor/github.com/docker/docker/pkg/term/winsize_aix_cgo.go new file mode 100644 index 0000000..de6954a --- /dev/null +++ b/vendor/github.com/docker/docker/pkg/term/winsize_aix_cgo.go @@ -0,0 +1,41 @@ +// +build aix,cgo + +package term + +import ( + "syscall" + "unsafe" +) + +/* +#include +#include +#include + +// Small wrapper to get rid of variadic args of ioctl() +int my_ioctl(int fd, u_int cmd, struct winsize *ws) { + return ioctl(fd, cmd, ws); +} +*/ +import "C" + +// GetWinsize returns the window size based on the specified file descriptor. +func GetWinsize(fd uintptr) (*Winsize, error) { + ws := &Winsize{} + ret, err := C.my_ioctl(C.int(fd), C.u_int(syscall.TIOCGWINSZ & 0xffffffff), (*C.struct_winsize)(unsafe.Pointer(ws))) + // Skip retval = 0 + if ret == 0 { + return ws, nil + } + return ws, err +} + +// SetWinsize tries to set the specified window size for the specified file descriptor. +func SetWinsize(fd uintptr, ws *Winsize) error { + ret, err := C.my_ioctl(C.int(fd), C.u_int(syscall.TIOCSWINSZ & 0xffffffff), (*C.struct_winsize)(unsafe.Pointer(ws))) + // Skip retval = 0 + if ret == 0 { + return nil + } + return err +} diff --git a/vendor/golang.org/x/crypto/ssh/terminal/util_aix.go b/vendor/golang.org/x/crypto/ssh/terminal/util_aix.go new file mode 100644 index 0000000..66183f8 --- /dev/null +++ b/vendor/golang.org/x/crypto/ssh/terminal/util_aix.go @@ -0,0 +1,79 @@ +// Based on ssh/terminal: +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package terminal + +import ( + "syscall" +) + +// State represents the state of the terminal. +type State struct { + termios syscall.Termios +} + +// IsTerminal returns true if the given file descriptor is a terminal. +func IsTerminal(fd int) bool { + var termios syscall.Termios + err := syscall.Tcgetattr(fd, &termios) + return err == nil +} + +// MakeRaw put the terminal connected to the given file descriptor into raw +// mode and returns the previous state of the terminal so that it can be +// restored. +func MakeRaw(fd int) (*State, error) { + var oldState State + if err := syscall.Tcgetattr(fd, &oldState.termios); err != nil { + return nil, err + } + + newState := oldState.termios + newState.Iflag &^= syscall.IGNBRK | syscall.BRKINT | syscall.PARMRK | syscall.ISTRIP | syscall.INLCR | syscall.IGNCR | syscall.ICRNL | syscall.IXON + newState.Oflag &^= syscall.OPOST + newState.Lflag &^= syscall.ECHO | syscall.ECHONL | syscall.ICANON | syscall.ISIG | syscall.IEXTEN + newState.Cflag &^= syscall.CSIZE | syscall.PARENB + newState.Cflag |= syscall.CS8 + + if err := syscall.Tcsetattr(fd, syscall.TCSANOW, &newState); err != nil { + return nil, err + } + return &oldState, nil +} + +// Restore restores the terminal connected to the given file descriptor to a +// previous state. +func Restore(fd int, oldState *State) error { + return syscall.Tcsetattr(fd, syscall.TCSANOW, &oldState.termios) +} + +// passwordReader is an io.Reader that reads from a specific file descriptor. +type passwordReader int + +func (r passwordReader) Read(buf []byte) (int, error) { + return syscall.Read(int(r), buf) +} + +// ReadPassword reads a line of input from a terminal without local echo. This +// is commonly used for inputting passwords and other sensitive data. The slice +// returned does not include the \n. +func ReadPassword(fd int) ([]byte, error) { + var oldState syscall.Termios + if err := syscall.Tcgetattr(fd, &oldState); err != nil { + return nil, err + } + + newState := oldState + newState.Lflag &^= syscall.ECHO | syscall.ECHOE | syscall.ECHOK | syscall.ECHONL + if err := syscall.Tcsetattr(fd, syscall.TCSANOW, &newState); err != nil { + return nil, err + } + + defer func() { + syscall.Tcsetattr(fd, syscall.TCSANOW, &oldState) + }() + + return readPasswordLine(passwordReader(fd)) +} diff --git a/vendor/k8s.io/kubernetes/pkg/kubectl/util/term/resizeevents.go b/vendor/k8s.io/kubernetes/pkg/kubectl/util/term/resizeevents.go index e3476f9..c88cb06 100644 --- a/vendor/k8s.io/kubernetes/pkg/kubectl/util/term/resizeevents.go +++ b/vendor/k8s.io/kubernetes/pkg/kubectl/util/term/resizeevents.go @@ -1,4 +1,4 @@ -// +build !windows +// +build !windows,!aix /* Copyright 2016 The Kubernetes Authors. diff --git a/vendor/k8s.io/kubernetes/pkg/kubectl/util/term/resizeevents_aix.go b/vendor/k8s.io/kubernetes/pkg/kubectl/util/term/resizeevents_aix.go new file mode 100644 index 0000000..a6bca64 --- /dev/null +++ b/vendor/k8s.io/kubernetes/pkg/kubectl/util/term/resizeevents_aix.go @@ -0,0 +1,63 @@ +// +build aix + +// This is a copy of resizeevents.go, except it uses syscall package instead of unix + +/* +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 term + +import ( + "os" + "os/signal" + "syscall" + + "k8s.io/apimachinery/pkg/util/runtime" + "k8s.io/client-go/tools/remotecommand" +) + +// monitorResizeEvents spawns a goroutine that waits for SIGWINCH signals (these indicate the +// terminal has resized). After receiving a SIGWINCH, this gets the terminal size and tries to send +// it to the resizeEvents channel. The goroutine stops when the stop channel is closed. +func monitorResizeEvents(fd uintptr, resizeEvents chan<- remotecommand.TerminalSize, stop chan struct{}) { + go func() { + defer runtime.HandleCrash() + + winch := make(chan os.Signal, 1) + signal.Notify(winch, syscall.SIGWINCH) + defer signal.Stop(winch) + + for { + select { + case <-winch: + size := GetSize(fd) + if size == nil { + return + } + + // try to send size + select { + case resizeEvents <- *size: + // success + default: + // not sent + } + case <-stop: + return + } + } + }() +} diff --git a/vendor/k8s.io/kubernetes/pkg/kubectl/util/umask.go b/vendor/k8s.io/kubernetes/pkg/kubectl/util/umask.go index 93e1447..e11f5a7 100644 --- a/vendor/k8s.io/kubernetes/pkg/kubectl/util/umask.go +++ b/vendor/k8s.io/kubernetes/pkg/kubectl/util/umask.go @@ -1,4 +1,4 @@ -// +build !windows +// +build !windows,!aix /* Copyright 2014 The Kubernetes Authors. diff --git a/vendor/k8s.io/kubernetes/pkg/kubectl/util/umask_aix.go b/vendor/k8s.io/kubernetes/pkg/kubectl/util/umask_aix.go new file mode 100644 index 0000000..0016861 --- /dev/null +++ b/vendor/k8s.io/kubernetes/pkg/kubectl/util/umask_aix.go @@ -0,0 +1,29 @@ +// +build aix + +// This is a copy of umask.go, except it uses syscall package instead of unix + +/* +Copyright 2014 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 util + +import ( + "syscall" +) + +func Umask(mask int) (old int, err error) { + return syscall.Umask(mask), nil +}