// 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
}
func (o *RetryOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command, out io.Writer, args []string) error {
if len(args) == 0 && len(o.Filenames) == 0 {
return kcmdutil.UsageError(cmd, cmd.Use)
}
o.Mapper, o.Typer = f.Object(false)
o.Encoder = f.JSONEncoder()
o.Out = out
cmdNamespace, enforceNamespace, err := f.DefaultNamespace()
if err != nil {
return err
}
_, _, o.Clientset, err = f.Clients()
if err != nil {
return err
}
r := resource.NewBuilder(o.Mapper, o.Typer, resource.ClientMapperFunc(f.ClientForMapping), f.Decoder(true)).
NamespaceParam(cmdNamespace).DefaultNamespace().
FilenameParam(enforceNamespace, o.Recursive, o.Filenames...).
ResourceTypeOrNameArgs(true, args...).
ContinueOnError().
Latest().
Flatten().
Do()
err = r.Err()
if err != nil {
return err
}
o.Infos, err = r.Infos()
return err
}
func (o *RolloutLatestOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command, args []string, out io.Writer) error {
if len(args) != 1 {
return errors.New("one deployment config name is needed as argument.")
}
namespace, _, err := f.DefaultNamespace()
if err != nil {
return err
}
o.oc, o.kc, err = f.Clients()
if err != nil {
return err
}
o.mapper, o.typer = f.Object(false)
o.infos, err = resource.NewBuilder(o.mapper, o.typer, resource.ClientMapperFunc(f.ClientForMapping), f.Decoder(true)).
ContinueOnError().
NamespaceParam(namespace).
ResourceNames("deploymentconfigs", args[0]).
SingleResourceType().
Do().Infos()
if err != nil {
return err
}
o.out = out
o.shortOutput = kcmdutil.GetFlagString(cmd, "output") == "name"
o.again = kcmdutil.GetFlagBool(cmd, "again")
return nil
}
// ImportObjects imports objects into OpenShift from a particular location
// into a given namespace
func ImportObjects(f *clientcmd.Factory, ns, location string) error {
mapper, typer := f.Object(false)
schema, err := f.Validator(false, "")
if err != nil {
return err
}
data, err := bootstrap.Asset(location)
if err != nil {
return err
}
glog.V(8).Infof("Importing data:\n%s\n", string(data))
r := resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(f.ClientForMapping), f.Decoder(true)).
Schema(schema).
ContinueOnError().
NamespaceParam(ns).
DefaultNamespace().
Stream(bytes.NewBuffer(data), location).
Flatten().
Do()
return r.Visit(func(info *resource.Info, err error) error {
if err != nil {
return err
}
glog.V(5).Infof("Creating %s/%s", info.Namespace, info.Name)
if err = createAndRefresh(info); err != nil {
return cmdutil.AddSourceToErr("creating", info.Source, err)
}
return nil
})
}