// Create registers the given ReplicationController. func (rs *REST) Create(ctx api.Context, obj runtime.Object) (<-chan apiserver.RESTResult, error) { controller, ok := obj.(*api.ReplicationController) if !ok { return nil, fmt.Errorf("not a replication controller: %#v", obj) } if !api.ValidNamespace(ctx, &controller.ObjectMeta) { return nil, errors.NewConflict("controller", controller.Namespace, fmt.Errorf("Controller.Namespace does not match the provided context")) } if len(controller.Name) == 0 { controller.Name = util.NewUUID().String() } if errs := validation.ValidateReplicationController(controller); len(errs) > 0 { return nil, errors.NewInvalid("replicationController", controller.Name, errs) } api.FillObjectMetaSystemFields(ctx, &controller.ObjectMeta) return apiserver.MakeAsync(func() (runtime.Object, error) { err := rs.registry.CreateController(ctx, controller) if err != nil { return nil, err } return rs.registry.GetController(ctx, controller.Name) }), nil }
func (rs *REST) Create(ctx api.Context, obj runtime.Object) (<-chan apiserver.RESTResult, error) { minion, ok := obj.(*api.Minion) if !ok { return nil, fmt.Errorf("not a minion: %#v", obj) } if minion.Name == "" { return nil, fmt.Errorf("ID should not be empty: %#v", minion) } minion.CreationTimestamp = util.Now() return apiserver.MakeAsync(func() (runtime.Object, error) { err := rs.registry.CreateMinion(ctx, minion) if err != nil { return nil, err } minionName := minion.Name minion, err := rs.registry.GetMinion(ctx, minionName) if err == ErrNotHealty { return rs.toApiMinion(minionName), nil } if minion == nil { return nil, ErrDoesNotExist } if err != nil { return nil, err } return minion, nil }), nil }
func (rs *REST) Create(obj runtime.Object) (<-chan runtime.Object, error) { minion, ok := obj.(*api.Minion) if !ok { return nil, fmt.Errorf("not a minion: %#v", obj) } if minion.ID == "" { return nil, fmt.Errorf("ID should not be empty: %#v", minion) } minion.CreationTimestamp = util.Now() return apiserver.MakeAsync(func() (runtime.Object, error) { err := rs.registry.Insert(minion.ID) if err != nil { return nil, err } contains, err := rs.registry.Contains(minion.ID) if err != nil { return nil, err } if contains { return rs.toApiMinion(minion.ID), nil } return nil, fmt.Errorf("unable to add minion %#v", minion) }), nil }
// Update satisfies the RESTStorage interface. func (rs *REST) Update(ctx api.Context, obj runtime.Object) (<-chan apiserver.RESTResult, error) { minion, ok := obj.(*api.Node) if !ok { return nil, fmt.Errorf("not a minion: %#v", obj) } // This is hacky, but minions don't really have a namespace, but kubectl currently automatically // stuffs one in there. Fix it here temporarily until we fix kubectl if minion.Namespace == api.NamespaceDefault { minion.Namespace = api.NamespaceNone } // Clear out the self link, if specified, since it's not in the registry either. minion.SelfLink = "" // TODO: GetMinion will health check the minion, but we shouldn't require the minion to be // running for updating labels. oldMinion, err := rs.registry.GetMinion(ctx, minion.Name) if err != nil { return nil, err } if errs := validation.ValidateMinionUpdate(oldMinion, minion); len(errs) > 0 { return nil, kerrors.NewInvalid("minion", minion.Name, errs) } return apiserver.MakeAsync(func() (runtime.Object, error) { err := rs.registry.UpdateMinion(ctx, minion) if err != nil { return nil, err } return rs.registry.GetMinion(ctx, minion.Name) }), nil }
func (rs *REST) Update(ctx api.Context, obj runtime.Object) (<-chan apiserver.RESTResult, error) { service := obj.(*api.Service) if !api.ValidNamespace(ctx, &service.ObjectMeta) { return nil, errors.NewConflict("service", service.Namespace, fmt.Errorf("Service.Namespace does not match the provided context")) } if errs := validation.ValidateService(service, rs.registry, ctx); len(errs) > 0 { return nil, errors.NewInvalid("service", service.Name, errs) } return apiserver.MakeAsync(func() (runtime.Object, error) { cur, err := rs.registry.GetService(ctx, service.Name) if err != nil { return nil, err } if service.Spec.PortalIP != cur.Spec.PortalIP { // TODO: Would be nice to pass "field is immutable" to users. el := errors.ValidationErrorList{errors.NewFieldInvalid("spec.portalIP", service.Spec.PortalIP)} return nil, errors.NewInvalid("service", service.Name, el) } // Copy over non-user fields. service.Spec.ProxyPort = cur.Spec.ProxyPort // TODO: check to see if external load balancer status changed err = rs.registry.UpdateService(ctx, service) if err != nil { return nil, err } return rs.registry.GetService(ctx, service.Name) }), nil }
func (sr *ServiceRegistryStorage) Create(obj interface{}) (<-chan interface{}, error) { srv := obj.(api.Service) if srv.ID == "" { return nil, fmt.Errorf("ID should not be empty: %#v", srv) } return apiserver.MakeAsync(func() (interface{}, error) { // TODO: Consider moving this to a rectification loop, so that we make/remove external load balancers // correctly no matter what http operations happen. if srv.CreateExternalLoadBalancer { var balancer cloudprovider.TCPLoadBalancer var ok bool if sr.cloud != nil { balancer, ok = sr.cloud.TCPLoadBalancer() } if ok && balancer != nil { hosts, err := sr.machines.List() if err != nil { return nil, err } err = balancer.CreateTCPLoadBalancer(srv.ID, "us-central1", srv.Port, hosts) if err != nil { return nil, err } } else { return nil, fmt.Errorf("requested an external service, but no cloud provider supplied.") } } // TODO actually wait for the object to be fully created here. err := sr.registry.CreateService(srv) if err != nil { return nil, err } return sr.registry.GetService(srv.ID) }), nil }
// Create registers the given ReplicationController. func (rs *REST) Create(ctx api.Context, obj runtime.Object) (<-chan apiserver.RESTResult, error) { controller, ok := obj.(*api.ReplicationController) if !ok { return nil, fmt.Errorf("not a replication controller: %#v", obj) } if !api.ValidNamespace(ctx, &controller.ObjectMeta) { return nil, errors.NewConflict("controller", controller.Namespace, fmt.Errorf("Controller.Namespace does not match the provided context")) } if len(controller.Name) == 0 { controller.Name = util.NewUUID().String() } // Pod Manifest ID should be assigned by the pod API controller.DesiredState.PodTemplate.DesiredState.Manifest.ID = "" if errs := validation.ValidateReplicationController(controller); len(errs) > 0 { return nil, errors.NewInvalid("replicationController", controller.Name, errs) } controller.CreationTimestamp = util.Now() return apiserver.MakeAsync(func() (runtime.Object, error) { err := rs.registry.CreateController(ctx, controller) if err != nil { return nil, err } return rs.registry.GetController(ctx, controller.Name) }), nil }
func (rs *RegistryStorage) Delete(id string) (<-chan interface{}, error) { service, err := rs.registry.GetService(id) if err != nil { return nil, err } return apiserver.MakeAsync(func() (interface{}, error) { rs.deleteExternalLoadBalancer(service) return &api.Status{Status: api.StatusSuccess}, rs.registry.DeleteService(id) }), nil }
func (rs *REST) Delete(id string) (<-chan runtime.Object, error) { service, err := rs.registry.GetService(id) if err != nil { return nil, err } return apiserver.MakeAsync(func() (runtime.Object, error) { rs.deleteExternalLoadBalancer(service) return &api.Status{Status: api.StatusSuccess}, rs.registry.DeleteService(id) }), nil }
func (rs *REST) Delete(ctx api.Context, id string) (<-chan apiserver.RESTResult, error) { service, err := rs.registry.GetService(ctx, id) if err != nil { return nil, err } rs.portalMgr.Release(net.ParseIP(service.Spec.PortalIP)) return apiserver.MakeAsync(func() (runtime.Object, error) { rs.deleteExternalLoadBalancer(service) return &api.Status{Status: api.StatusSuccess}, rs.registry.DeleteService(ctx, id) }), nil }
func (storage *MinionRegistryStorage) Delete(id string) (<-chan interface{}, error) { exists, err := storage.registry.Contains(id) if !exists { return nil, ErrDoesNotExist } if err != nil { return nil, err } return apiserver.MakeAsync(func() (interface{}, error) { return api.Status{Status: api.StatusSuccess}, storage.registry.Delete(id) }), nil }
func (rs *REST) Delete(ctx api.Context, id string) (<-chan apiserver.RESTResult, error) { minion, err := rs.registry.GetMinion(ctx, id) if minion == nil { return nil, ErrDoesNotExist } if err != nil { return nil, err } return apiserver.MakeAsync(func() (runtime.Object, error) { return &api.Status{Status: api.StatusSuccess}, rs.registry.DeleteMinion(ctx, id) }), nil }
func (rs *REST) Delete(id string) (<-chan runtime.Object, error) { exists, err := rs.registry.Contains(id) if !exists { return nil, ErrDoesNotExist } if err != nil { return nil, err } return apiserver.MakeAsync(func() (runtime.Object, error) { return &api.Status{Status: api.StatusSuccess}, rs.registry.Delete(id) }), nil }
func (rs *RegistryStorage) Update(obj interface{}) (<-chan interface{}, error) { pod := obj.(*api.Pod) if errs := api.ValidatePod(pod); len(errs) > 0 { return nil, apiserver.NewInvalidErr("pod", pod.ID, errs) } return apiserver.MakeAsync(func() (interface{}, error) { if err := rs.registry.UpdatePod(*pod); err != nil { return nil, err } return rs.registry.GetPod(pod.ID) }), nil }
func (storage *PodRegistryStorage) Create(pod interface{}) (<-chan interface{}, error) { podObj := pod.(api.Pod) if len(podObj.ID) == 0 { return nil, fmt.Errorf("id is unspecified: %#v", pod) } machine, err := storage.scheduler.Schedule(podObj) if err != nil { return nil, err } return apiserver.MakeAsync(func() interface{} { return pod }), storage.registry.CreatePod(machine, podObj) }
// Create attempts to make the assignment indicated by the binding it recieves. func (b *BindingStorage) Create(obj interface{}) (<-chan interface{}, error) { binding, ok := obj.(*api.Binding) if !ok { return nil, fmt.Errorf("incorrect type: %#v", obj) } return apiserver.MakeAsync(func() (interface{}, error) { if err := b.registry.ApplyBinding(binding); err != nil { return nil, err } return &api.Status{Status: api.StatusSuccess}, nil }), nil }
func (rs *REST) Update(obj runtime.Object) (<-chan runtime.Object, error) { pod := obj.(*api.Pod) if errs := validation.ValidatePod(pod); len(errs) > 0 { return nil, errors.NewInvalid("pod", pod.ID, errs) } return apiserver.MakeAsync(func() (runtime.Object, error) { if err := rs.registry.UpdatePod(pod); err != nil { return nil, err } return rs.registry.GetPod(pod.ID) }), nil }
// Create attempts to make the assignment indicated by the binding it recieves. func (b *REST) Create(ctx api.Context, obj runtime.Object) (<-chan apiserver.RESTResult, error) { binding, ok := obj.(*api.Binding) if !ok { return nil, fmt.Errorf("incorrect type: %#v", obj) } return apiserver.MakeAsync(func() (runtime.Object, error) { if err := b.registry.ApplyBinding(ctx, binding); err != nil { return nil, err } return &api.Status{Status: api.StatusSuccess}, nil }), nil }
func (rs *RegistryStorage) Update(obj interface{}) (<-chan interface{}, error) { pod := obj.(*api.Pod) if errs := api.ValidatePod(pod); len(errs) > 0 { return nil, fmt.Errorf("Validation errors: %v", errs) } return apiserver.MakeAsync(func() (interface{}, error) { if err := rs.registry.UpdatePod(*pod); err != nil { return nil, err } return rs.waitForPodRunning(*pod) }), nil }
// Update satisfies the RESTStorage interface. func (rs *REST) Update(ctx api.Context, obj runtime.Object) (<-chan apiserver.RESTResult, error) { endpoints, ok := obj.(*api.Endpoints) if !ok { return nil, fmt.Errorf("not an endpoints: %#v", obj) } return apiserver.MakeAsync(func() (runtime.Object, error) { err := rs.registry.UpdateEndpoints(ctx, endpoints) if err != nil { return nil, err } return rs.registry.GetEndpoints(ctx, endpoints.Name) }), nil }
func (rs *REST) Delete(ctx api.Context, id string) (<-chan apiserver.RESTResult, error) { obj, err := rs.registry.Get(ctx, id) if err != nil { return nil, err } _, ok := obj.(*api.Event) if !ok { return nil, fmt.Errorf("invalid object type") } return apiserver.MakeAsync(func() (runtime.Object, error) { return &api.Status{Status: api.StatusSuccess}, rs.registry.Delete(ctx, id) }), nil }
func (sr *ServiceRegistryStorage) Update(obj interface{}) (<-chan interface{}, error) { srv := obj.(api.Service) if srv.ID == "" { return nil, fmt.Errorf("ID should not be empty: %#v", srv) } return apiserver.MakeAsync(func() (interface{}, error) { // TODO: check to see if external load balancer status changed err := sr.registry.UpdateService(srv) if err != nil { return nil, err } return sr.registry.GetService(srv.ID) }), nil }
func (rs *REST) Update(obj runtime.Object) (<-chan runtime.Object, error) { srv := obj.(*api.Service) if errs := validation.ValidateService(srv); len(errs) > 0 { return nil, errors.NewInvalid("service", srv.ID, errs) } return apiserver.MakeAsync(func() (runtime.Object, error) { // TODO: check to see if external load balancer status changed err := rs.registry.UpdateService(srv) if err != nil { return nil, err } return rs.registry.GetService(srv.ID) }), nil }
func (storage *PodRegistryStorage) Update(obj interface{}) (<-chan interface{}, error) { pod := obj.(api.Pod) if len(pod.ID) == 0 { return nil, fmt.Errorf("id is unspecified: %#v", pod) } return apiserver.MakeAsync(func() (interface{}, error) { err := storage.registry.UpdatePod(pod) if err != nil { return nil, err } return storage.registry.GetPod(pod.ID) }), nil }
func (storage *PodRegistryStorage) Update(obj interface{}) (<-chan interface{}, error) { pod := obj.(api.Pod) if len(pod.ID) == 0 { return nil, fmt.Errorf("ID should not be empty: %#v", pod) } return apiserver.MakeAsync(func() (interface{}, error) { err := storage.registry.UpdatePod(pod) if err != nil { return nil, err } return storage.waitForPodRunning(pod) }), nil }
func (rs *RegistryStorage) Update(obj interface{}) (<-chan interface{}, error) { srv := obj.(*api.Service) if errs := api.ValidateService(srv); len(errs) > 0 { return nil, apiserver.NewInvalidErr("service", srv.ID, errs) } return apiserver.MakeAsync(func() (interface{}, error) { // TODO: check to see if external load balancer status changed err := rs.registry.UpdateService(*srv) if err != nil { return nil, err } return rs.registry.GetService(srv.ID) }), nil }
func (rs *REST) Create(ctx api.Context, obj runtime.Object) (<-chan apiserver.RESTResult, error) { event, ok := obj.(*api.Event) if !ok { return nil, fmt.Errorf("invalid object type") } event.CreationTimestamp = util.Now() return apiserver.MakeAsync(func() (runtime.Object, error) { err := rs.registry.Create(ctx, event.Name, event) if err != nil { return nil, err } return rs.registry.Get(ctx, event.Name) }), nil }
func (rs *REST) Update(ctx api.Context, obj runtime.Object) (<-chan apiserver.RESTResult, error) { pod := obj.(*api.Pod) if !api.ValidNamespace(ctx, &pod.ObjectMeta) { return nil, errors.NewConflict("pod", pod.Namespace, fmt.Errorf("Pod.Namespace does not match the provided context")) } if errs := validation.ValidatePod(pod); len(errs) > 0 { return nil, errors.NewInvalid("pod", pod.Name, errs) } return apiserver.MakeAsync(func() (runtime.Object, error) { if err := rs.registry.UpdatePod(ctx, pod); err != nil { return nil, err } return rs.registry.GetPod(ctx, pod.Name) }), nil }
// Update replaces a given ReplicationController instance with an existing instance in storage.registry. func (storage *ControllerRegistryStorage) Update(obj interface{}) (<-chan interface{}, error) { controller, ok := obj.(*api.ReplicationController) if !ok { return nil, fmt.Errorf("not a replication controller: %#v", obj) } if errs := api.ValidateReplicationController(controller); len(errs) > 0 { return nil, fmt.Errorf("Validation errors: %v", errs) } return apiserver.MakeAsync(func() (interface{}, error) { err := storage.registry.UpdateController(*controller) if err != nil { return nil, err } return storage.waitForController(*controller) }), nil }
// Update replaces a given ReplicationController instance with an existing // instance in storage.registry. func (rs *RegistryStorage) Update(obj interface{}) (<-chan interface{}, error) { controller, ok := obj.(*api.ReplicationController) if !ok { return nil, fmt.Errorf("not a replication controller: %#v", obj) } if errs := validation.ValidateReplicationController(controller); len(errs) > 0 { return nil, errors.NewInvalid("replicationController", controller.ID, errs) } return apiserver.MakeAsync(func() (interface{}, error) { err := rs.registry.UpdateController(*controller) if err != nil { return nil, err } return rs.registry.GetController(controller.ID) }), nil }