func (v versionToResourceToFieldMapping) filterField(groupVersion unversioned.GroupVersion, resourceType, field, value string) (newField, newValue string, err error) { rMapping, ok := v[groupVersion] if !ok { glog.Warningf("Field selector: %v - %v - %v - %v: need to check if this is versioned correctly.", groupVersion, resourceType, field, value) return field, value, nil } newField, newValue, err = rMapping.filterField(resourceType, field, value) if err != nil { // This is only a warning until we find and fix all of the client's usages. glog.Warningf("Field selector: %v - %v - %v - %v: need to check if this is versioned correctly.", groupVersion, resourceType, field, value) return field, value, nil } return newField, newValue, nil }
// GetMountRefs finds all other references to the device referenced // by mountPath; returns a list of paths. func GetMountRefs(mounter Interface, mountPath string) ([]string, error) { mps, err := mounter.List() if err != nil { return nil, err } // Find the device name. deviceName := "" for i := range mps { if mps[i].Path == mountPath { deviceName = mps[i].Device break } } // Find all references to the device. var refs []string if deviceName == "" { glog.Warningf("could not determine device for path: %q", mountPath) } else { for i := range mps { if mps[i].Device == deviceName && mps[i].Path != mountPath { refs = append(refs, mps[i].Path) } } } return refs, nil }
// forward dials the remote host specific in req, upgrades the request, starts // listeners for each port specified in ports, and forwards local connections // to the remote host via streams. func (pf *PortForwarder) forward() error { var err error listenSuccess := false for _, port := range pf.ports { err = pf.listenOnPort(&port) switch { case err == nil: listenSuccess = true default: glog.Warningf("Unable to listen on port %d: %v", port.Local, err) } } if !listenSuccess { return fmt.Errorf("Unable to listen on any of the requested ports: %v", pf.ports) } close(pf.Ready) // wait for interrupt or conn closure select { case <-pf.stopChan: case <-pf.streamConn.CloseChan(): util.HandleError(errors.New("lost connection to pod")) } return nil }
// WarnWordSepNormalizeFunc changes and warns for flags that contain "_" separators func WarnWordSepNormalizeFunc(f *pflag.FlagSet, name string) pflag.NormalizedName { if strings.Contains(name, "_") { nname := strings.Replace(name, "_", "-", -1) glog.Warningf("%s is DEPRECATED and will be removed in a future version. Use %s instead.", name, nname) return pflag.NormalizedName(nname) } return pflag.NormalizedName(name) }
// newSpdyStream is the internal new stream handler used by spdystream.Connection.Serve. // It calls connection's newStreamHandler, giving it the opportunity to accept or reject // the stream. If newStreamHandler returns an error, the stream is rejected. If not, the // stream is accepted and registered with the connection. func (c *connection) newSpdyStream(stream *spdystream.Stream) { err := c.newStreamHandler(stream) rejectStream := (err != nil) if rejectStream { glog.Warningf("Stream rejected: %v", err) stream.Reset() return } c.registerStream(stream) stream.SendReply(http.Header{}, rejectStream) }
// BuildConfigFromFlags is a helper function that builds configs from a master // url or a kubeconfig filepath. These are passed in as command line flags for cluster // components. Warnings should reflect this usage. If neither masterUrl or kubeconfigPath // are passed in we fallback to inClusterConfig. If inClusterConfig fails, we fallback // to the default config. func BuildConfigFromFlags(masterUrl, kubeconfigPath string) (*client.Config, error) { if kubeconfigPath == "" && masterUrl == "" { glog.Warningf("Neither --kubeconfig nor --master was specified. Using the inClusterConfig. This might not work.") kubeconfig, err := client.InClusterConfig() if err == nil { return kubeconfig, nil } glog.Warning("error creating inClusterConfig, falling back to default config: %v", err) } return NewNonInteractiveDeferredLoadingClientConfig( &ClientConfigLoadingRules{ExplicitPath: kubeconfigPath}, &ConfigOverrides{ClusterInfo: clientcmdapi.Cluster{Server: masterUrl}}).ClientConfig() }
// New returns a new Interface which will exec iptables. func New(exec utilexec.Interface, dbus utildbus.Interface, protocol Protocol) Interface { vstring, err := getIptablesVersionString(exec) if err != nil { glog.Warningf("Error checking iptables version, assuming version at least %s: %v", MinCheckVersion, err) vstring = MinCheckVersion } runner := &runner{ exec: exec, dbus: dbus, protocol: protocol, hasCheck: getIptablesHasCheckCommand(vstring), waitFlag: getIptablesWaitFlag(vstring), } runner.connectToFirewallD() return runner }
// formatAndMount uses unix utils to format and mount the given disk func (mounter *SafeFormatAndMount) formatAndMount(source string, target string, fstype string, options []string) error { options = append(options, "defaults") // Run fsck on the disk to fix repairable issues args := []string{"-a", source} cmd := mounter.Runner.Command("fsck", args...) out, err := cmd.CombinedOutput() if err != nil { ee, isExitError := err.(utilExec.ExitError) switch { case err == utilExec.ErrExecutableNotFound: glog.Warningf("'fsck' not found on system; continuing mount without running 'fsck'.") case isExitError && ee.ExitStatus() == fsckErrorsCorrected: glog.Infof("Device %s has errors which were corrected by fsck.", source) case isExitError && ee.ExitStatus() == fsckErrorsUncorrected: return fmt.Errorf("'fsck' found errors on device %s but could not correct them: %s.", source, string(out)) case isExitError && ee.ExitStatus() > fsckErrorsUncorrected: glog.Infof("`fsck` error %s", string(out)) } } // Try to mount the disk err = mounter.Interface.Mount(source, target, fstype, options) if err != nil { // It is possible that this disk is not formatted. Double check using diskLooksUnformatted notFormatted, err := mounter.diskLooksUnformatted(source) if err == nil && notFormatted { args = []string{source} // Disk is unformatted so format it. // Use 'ext4' as the default if len(fstype) == 0 { fstype = "ext4" } if fstype == "ext4" || fstype == "ext3" { args = []string{"-E", "lazy_itable_init=0,lazy_journal_init=0", "-F", source} } cmd := mounter.Runner.Command("mkfs."+fstype, args...) _, err := cmd.CombinedOutput() if err == nil { // the disk has been formatted sucessfully try to mount it again. return mounter.Interface.Mount(source, target, fstype, options) } return err } } return err }
func DialURL(url *url.URL, transport http.RoundTripper) (net.Conn, error) { dialAddr := netutil.CanonicalAddr(url) dialer, _ := util.Dialer(transport) switch url.Scheme { case "http": if dialer != nil { return dialer("tcp", dialAddr) } return net.Dial("tcp", dialAddr) case "https": // Get the tls config from the transport if we recognize it var tlsConfig *tls.Config var tlsConn *tls.Conn var err error tlsConfig, _ = util.TLSClientConfig(transport) if dialer != nil { // We have a dialer; use it to open the connection, then // create a tls client using the connection. netConn, err := dialer("tcp", dialAddr) if err != nil { return nil, err } if tlsConfig == nil { // tls.Client requires non-nil config glog.Warningf("using custom dialer with no TLSClientConfig. Defaulting to InsecureSkipVerify") // tls.Handshake() requires ServerName or InsecureSkipVerify tlsConfig = &tls.Config{ InsecureSkipVerify: true, } } else if len(tlsConfig.ServerName) == 0 && !tlsConfig.InsecureSkipVerify { // tls.Handshake() requires ServerName or InsecureSkipVerify // infer the ServerName from the hostname we're connecting to. inferredHost := dialAddr if host, _, err := net.SplitHostPort(dialAddr); err == nil { inferredHost = host } // Make a copy to avoid polluting the provided config tlsConfigCopy := *tlsConfig tlsConfigCopy.ServerName = inferredHost tlsConfig = &tlsConfigCopy } tlsConn = tls.Client(netConn, tlsConfig) if err := tlsConn.Handshake(); err != nil { netConn.Close() return nil, err } } else { // Dial tlsConn, err = tls.Dial("tcp", dialAddr, tlsConfig) if err != nil { return nil, err } } // Return if we were configured to skip validation if tlsConfig != nil && tlsConfig.InsecureSkipVerify { return tlsConn, nil } // Verify host, _, _ := net.SplitHostPort(dialAddr) if err := tlsConn.VerifyHostname(host); err != nil { tlsConn.Close() return nil, err } return tlsConn, nil default: return nil, fmt.Errorf("Unknown scheme: %s", url.Scheme) } }