func (handler *ContainersHandlersImpl) RemoveContainerHandler(params containers.ContainerRemoveParams) middleware.Responder { defer trace.End(trace.Begin(params.ID)) // get the indicated container for removal cID := uid.Parse(params.ID) h := exec.GetContainer(context.Background(), cID) if h == nil || h.ExecConfig == nil { return containers.NewContainerRemoveNotFound() } container := exec.Containers.Container(h.ExecConfig.ID) if container == nil { return containers.NewGetStateNotFound() } // NOTE: this should allowing batching of operations, as with Create, Start, Stop, et al err := container.Remove(context.Background(), handler.handlerCtx.Session) if err != nil { switch err := err.(type) { case exec.NotFoundError: return containers.NewContainerRemoveNotFound() case exec.RemovePowerError: return containers.NewContainerRemoveConflict().WithPayload(&models.Error{Message: err.Error()}) default: return containers.NewContainerRemoveInternalServerError() } } return containers.NewContainerRemoveOK() }
func (c *Container) Refresh(ctx context.Context) error { c.Lock() defer c.Unlock() // this will "refresh" the container executor config that contains // the current ip addresses h := exec.GetContainer(ctx, c.ID()) if h == nil { return fmt.Errorf("could not find container %s", c.ID()) } defer h.Close() for _, e := range c.endpoints { s := e.Scope() if !s.isDynamic() { continue } ne := h.ExecConfig.Networks[s.Name()] if ne == nil { return fmt.Errorf("container config does not have info for network scope %s", s.Name()) } e.ip = ne.Assigned.IP if err := s.Refresh(h); err != nil { return err } } return nil }
func (handler *ContainersHandlersImpl) GetHandler(params containers.GetParams) middleware.Responder { defer trace.End(trace.Begin(params.ID)) h := exec.GetContainer(context.Background(), uid.Parse(params.ID)) if h == nil { return containers.NewGetNotFound().WithPayload(&models.Error{Message: fmt.Sprintf("container %s not found", params.ID)}) } return containers.NewGetOK().WithPayload(h.String()) }
func (handler *ScopesHandlersImpl) listScopes(idName string) ([]*models.ScopeConfig, error) { _scopes, err := handler.netCtx.Scopes(&idName) if err != nil { return nil, err } cfgs := make([]*models.ScopeConfig, len(_scopes)) updated := make(map[uid.UID]*exec.Handle) for i, s := range _scopes { for _, e := range s.Endpoints() { // update the container config, if necessary // do not need do this for non-bridge scopes, since // IPAM is done by the port layer. For other // scopes types, like external, the network // may be using DHCP, in which case we need to // get the current IP address, and other network // info from the container VM. if s.Type() != network.BridgeScopeType { var h *exec.Handle c := e.Container().ID() if h = updated[c]; h == nil { h = exec.GetContainer(c) if _, err := h.Update(context.Background(), handler.handlerCtx.Session); err != nil { return nil, err } updated[c] = h } if err = handler.netCtx.UpdateContainer(h); err != nil { return nil, err } } } cfgs[i] = toScopeConfig(s) } for _, h := range updated { h.Close() } return cfgs, nil }
// handleEvent processes events func handleEvent(netctx *Context, ie events.Event) { switch ie.String() { case events.ContainerPoweredOff: handle := exec.GetContainer(context.Background(), uid.Parse(ie.Reference())) if handle == nil { log.Errorf("Container %s not found - unable to UnbindContainer", ie.Reference()) return } defer handle.Close() if _, err := netctx.UnbindContainer(handle); err != nil { log.Warnf("Failed to unbind container %s: %s", ie.Reference(), err) return } if err := handle.Commit(context.Background(), nil, nil); err != nil { log.Warnf("Failed to commit handle after network unbind for container %s: %s", ie.Reference(), err) } } return }