func (o *NewServiceAccountTokenOptions) Complete(args []string, requestedLabels string, f *clientcmd.Factory, cmd *cobra.Command) error {
if len(args) != 1 {
return cmdutil.UsageError(cmd, fmt.Sprintf("expected one service account name as an argument, got %q", args))
}
o.SAName = args[0]
if len(requestedLabels) > 0 {
labels, err := kubectl.ParseLabels(requestedLabels)
if err != nil {
return cmdutil.UsageError(cmd, err.Error())
}
o.Labels = labels
}
client, err := f.Client()
if err != nil {
return err
}
namespace, _, err := f.DefaultNamespace()
if err != nil {
return fmt.Errorf("could not retrieve default namespace: %v", err)
}
o.SAClient = client.ServiceAccounts(namespace)
o.SecretsClient = client.Secrets(namespace)
return nil
}
func (o *CreateKubeconfigOptions) Complete(args []string, f *clientcmd.Factory, cmd *cobra.Command) error {
if len(args) != 1 {
return cmdutil.UsageError(cmd, fmt.Sprintf("expected one service account name as an argument, got %q", args))
}
o.SAName = args[0]
client, err := f.Client()
if err != nil {
return err
}
namespace, _, err := f.DefaultNamespace()
if err != nil {
return err
}
o.RawConfig, err = f.OpenShiftClientConfig.RawConfig()
if err != nil {
return err
}
if len(o.ContextNamespace) == 0 {
o.ContextNamespace = namespace
}
o.SAClient = client.ServiceAccounts(namespace)
o.SecretsClient = client.Secrets(namespace)
return nil
}
// Execute() will run a command in a pod and streams the out/err
func Execute(factory *osclientcmd.Factory, command []string, pod *kapi.Pod, in io.Reader, out, errOut io.Writer) error {
config, err := factory.ClientConfig()
if err != nil {
return err
}
client, err := factory.Client()
if err != nil {
return err
}
execOptions := &kubecmd.ExecOptions{
StreamOptions: kubecmd.StreamOptions{
Namespace: pod.Namespace,
PodName: pod.Name,
ContainerName: pod.Name,
In: in,
Out: out,
Err: errOut,
Stdin: in != nil,
},
Executor: &kubecmd.DefaultRemoteExecutor{},
Client: client,
Config: config,
Command: command,
}
err = execOptions.Validate()
if err != nil {
return err
}
return execOptions.Run()
}
// newPortForwarder creates a new forwarder for use with rsync
func newPortForwarder(f *clientcmd.Factory, o *RsyncOptions) (forwarder, error) {
client, err := f.Client()
if err != nil {
return nil, err
}
config, err := f.ClientConfig()
if err != nil {
return nil, err
}
return &portForwarder{
Namespace: o.Namespace,
PodName: o.PodName(),
Client: client,
Config: config,
}, nil
}
// Complete applies the command environment to RshOptions
func (o *RshOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command, args []string) error {
switch {
case o.ForceTTY && o.DisableTTY:
return kcmdutil.UsageError(cmd, "you may not specify -t and -T together")
case o.ForceTTY:
o.TTY = true
case o.DisableTTY:
o.TTY = false
default:
o.TTY = term.IsTerminal(o.In)
}
if len(args) < 1 {
return kcmdutil.UsageError(cmd, "rsh requires a single Pod to connect to")
}
resource := args[0]
args = args[1:]
if len(args) > 0 {
o.Command = args
} else {
o.Command = []string{o.Executable}
}
namespace, _, err := f.DefaultNamespace()
if err != nil {
return err
}
o.Namespace = namespace
config, err := f.ClientConfig()
if err != nil {
return err
}
o.Config = config
client, err := f.Client()
if err != nil {
return err
}
o.Client = client
// TODO: Consider making the timeout configurable
o.PodName, err = f.PodForResource(resource, 10*time.Second)
return err
}
func newRemoteExecutor(f *clientcmd.Factory, o *RsyncOptions) (executor, error) {
config, err := f.ClientConfig()
if err != nil {
return nil, err
}
client, err := f.Client()
if err != nil {
return nil, err
}
return &remoteExecutor{
Namespace: o.Namespace,
PodName: o.PodName(),
ContainerName: o.ContainerName,
Config: config,
Client: client,
}, nil
}
func (o *GetServiceAccountTokenOptions) Complete(args []string, f *clientcmd.Factory, cmd *cobra.Command) error {
if len(args) != 1 {
return cmdutil.UsageError(cmd, fmt.Sprintf("expected one service account name as an argument, got %q", args))
}
o.SAName = args[0]
client, err := f.Client()
if err != nil {
return err
}
namespace, _, err := f.DefaultNamespace()
if err != nil {
return err
}
o.SAClient = client.ServiceAccounts(namespace)
o.SecretsClient = client.Secrets(namespace)
return nil
}
func newRsyncStrategy(f *clientcmd.Factory, c *cobra.Command, o *RsyncOptions) (copyStrategy, error) {
// Determine the rsh command to pass to the local rsync command
rsh := siblingCommand(c, "rsh")
rshCmd := []string{rsh}
// Append all original flags to rsh command
c.Flags().Visit(func(flag *pflag.Flag) {
if rshExcludeFlags.Has(flag.Name) {
return
}
rshCmd = append(rshCmd, fmt.Sprintf("--%s=%s", flag.Name, flag.Value.String()))
})
rshCmdStr := strings.Join(rshCmd, " ")
glog.V(4).Infof("Rsh command: %s", rshCmdStr)
remoteExec, err := newRemoteExecutor(f, o)
if err != nil {
return nil, err
}
// The blocking-io flag is used to resolve a sync issue when
// copying from the pod to the local machine
flags := []string{"-a", "--blocking-io", "--omit-dir-times", "--numeric-ids"}
flags = append(flags, rsyncFlagsFromOptions(o)...)
podName := o.Source.PodName
if o.Source.Local() {
podName = o.Destination.PodName
}
client, err := f.Client()
if err != nil {
return nil, err
}
return &rsyncStrategy{
Flags: flags,
RshCommand: rshCmdStr,
RemoteExecutor: remoteExec,
LocalExecutor: newLocalExecutor(),
podChecker: podAPIChecker{client, o.Namespace, podName},
}, nil
}
func getConfigMapRefValue(f *clientcmd.Factory, store *resourceStore, configMapSelector *kapi.ConfigMapKeySelector) (string, error) {
configMap, ok := store.configMapStore[configMapSelector.Name]
if !ok {
kubeClient, err := f.Client()
if err != nil {
return "", err
}
namespace, _, err := f.DefaultNamespace()
if err != nil {
return "", err
}
configMap, err = kubeClient.ConfigMaps(namespace).Get(configMapSelector.Name)
if err != nil {
return "", err
}
store.configMapStore[configMapSelector.Name] = configMap
}
if data, ok := configMap.Data[configMapSelector.Key]; ok {
return string(data), nil
}
return "", fmt.Errorf("key %s not found in config map %s", configMapSelector.Key, configMapSelector.Name)
}
func getSecretRefValue(f *clientcmd.Factory, store *resourceStore, secretSelector *kapi.SecretKeySelector) (string, error) {
secret, ok := store.secretStore[secretSelector.Name]
if !ok {
kubeClient, err := f.Client()
if err != nil {
return "", err
}
namespace, _, err := f.DefaultNamespace()
if err != nil {
return "", err
}
secret, err = kubeClient.Secrets(namespace).Get(secretSelector.Name)
if err != nil {
return "", err
}
store.secretStore[secretSelector.Name] = secret
}
if data, ok := secret.Data[secretSelector.Key]; ok {
return string(data), nil
}
return "", fmt.Errorf("key %s not found in secret %s", secretSelector.Key, secretSelector.Name)
}
// calculateIdlableAnnotationsByService calculates the list of objects involved in the idling process from a list of services in a file.
// Using the list of services, it figures out the associated scalable objects, and returns a map from the endpoints object for the services to
// the list of scalable resources associated with that endpoints object, as well as a map from CrossGroupObjectReferences to scale to 0 to the
// name of the associated service.
func (o *IdleOptions) calculateIdlableAnnotationsByService(f *clientcmd.Factory) (map[types.NamespacedName]idleUpdateInfo, map[unidlingapi.CrossGroupObjectReference]types.NamespacedName, error) {
// load our set of services
client, err := f.Client()
if err != nil {
return nil, nil, err
}
mapper, _ := f.Object(false)
podsLoaded := make(map[kapi.ObjectReference]*kapi.Pod)
getPod := func(ref kapi.ObjectReference) (*kapi.Pod, error) {
if pod, ok := podsLoaded[ref]; ok {
return pod, nil
}
pod, err := client.Pods(ref.Namespace).Get(ref.Name)
if err != nil {
return nil, err
}
podsLoaded[ref] = pod
return pod, nil
}
controllersLoaded := make(map[kapi.ObjectReference]runtime.Object)
helpers := make(map[unversioned.GroupKind]*resource.Helper)
getController := func(ref kapi.ObjectReference) (runtime.Object, error) {
if controller, ok := controllersLoaded[ref]; ok {
return controller, nil
}
gv, err := unversioned.ParseGroupVersion(ref.APIVersion)
if err != nil {
return nil, err
}
// just get the unversioned version of this
gk := unversioned.GroupKind{Group: gv.Group, Kind: ref.Kind}
helper, ok := helpers[gk]
if !ok {
var mapping *meta.RESTMapping
mapping, err = mapper.RESTMapping(unversioned.GroupKind{Group: gv.Group, Kind: ref.Kind}, "")
if err != nil {
return nil, err
}
var client resource.RESTClient
client, err = f.ClientForMapping(mapping)
if err != nil {
return nil, err
}
helper = resource.NewHelper(client, mapping)
helpers[gk] = helper
}
var controller runtime.Object
controller, err = helper.Get(ref.Namespace, ref.Name, false)
if err != nil {
return nil, err
}
controllersLoaded[ref] = controller
return controller, nil
}
targetScaleRefs := make(map[unidlingapi.CrossGroupObjectReference]types.NamespacedName)
endpointsInfo := make(map[types.NamespacedName]idleUpdateInfo)
decoder := f.Decoder(true)
err = o.svcBuilder.Do().Visit(func(info *resource.Info, err error) error {
if err != nil {
return err
}
endpoints, isEndpoints := info.Object.(*kapi.Endpoints)
if !isEndpoints {
return fmt.Errorf("you must specify endpoints, not %v (view available endpoints with \"%s get endpoints\").", info.Mapping.Resource, o.cmdFullName)
}
endpointsName := types.NamespacedName{
Namespace: endpoints.Namespace,
Name: endpoints.Name,
}
scaleRefs, err := findScalableResourcesForEndpoints(endpoints, decoder, getPod, getController)
if err != nil {
return fmt.Errorf("unable to calculate scalable resources for service %s/%s: %v", endpoints.Namespace, endpoints.Name, err)
}
for ref := range scaleRefs {
targetScaleRefs[ref] = endpointsName
}
idleInfo := idleUpdateInfo{
obj: endpoints,
scaleRefs: scaleRefs,
}
endpointsInfo[endpointsName] = idleInfo
return nil
})
return endpointsInfo, targetScaleRefs, err
}
// Complete verifies command line arguments and loads data from the command environment
func (o *RsyncOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command, args []string) error {
switch n := len(args); {
case n == 0:
cmd.Help()
fallthrough
case n < 2:
return kcmdutil.UsageError(cmd, "SOURCE_DIR and POD:DESTINATION_DIR are required arguments")
case n > 2:
return kcmdutil.UsageError(cmd, "only SOURCE_DIR and POD:DESTINATION_DIR should be specified as arguments")
}
// Set main command arguments
o.Source = args[0]
o.Destination = args[1]
// Determine pod name
var err error
o.PodName, o.DestinationDir, err = parseDestination(o.Destination)
if err != nil {
return kcmdutil.UsageError(cmd, err.Error())
}
// Use tar if running on windows
// TODO: Figure out how to use rsync in windows so that I/O can be
// redirected from the openshift native command to the cygwin rsync command
if runtime.GOOS == "windows" {
o.UseTar = true
}
namespace, _, err := f.DefaultNamespace()
if err != nil {
return err
}
o.Namespace = namespace
// Determine the Rsh command to use for rsync
if !o.UseTar {
rsh := siblingCommand(cmd, "rsh")
rshCmd := []string{rsh, "-n", o.Namespace}
if len(o.ContainerName) > 0 {
rshCmd = append(rshCmd, "-c", o.ContainerName)
}
o.RshCommand = strings.Join(rshCmd, " ")
glog.V(4).Infof("Rsh command: %s", o.RshCommand)
}
config, err := f.ClientConfig()
if err != nil {
return err
}
client, err := f.Client()
if err != nil {
return err
}
o.RemoteExecutor = &defaultRemoteExecutor{
Namespace: o.Namespace,
PodName: o.PodName,
ContainerName: o.ContainerName,
Config: config,
Client: client,
}
o.PodClient = client.Pods(namespace)
return nil
}