func (c *Client) BindUnit(instance *ServiceInstance, app bind.App, unit bind.Unit) error { log.Debugf("Calling bind of instance %q and %q unit at %q API", instance.Name, unit.GetIp(), instance.ServiceName) var resp *http.Response params := map[string][]string{ "app-host": {app.GetIp()}, "unit-host": {unit.GetIp()}, } resp, err := c.issueRequest("/resources/"+instance.GetIdentifier()+"/bind", "POST", params) if err != nil { return log.WrapError(errors.Wrapf(err, `Failed to bind the instance "%s/%s" to the unit %q`, instance.ServiceName, instance.Name, unit.GetIp())) } defer resp.Body.Close() switch resp.StatusCode { case http.StatusPreconditionFailed: return ErrInstanceNotReady case http.StatusNotFound: return ErrInstanceNotFoundInAPI } if resp.StatusCode > 299 { err = errors.Wrapf(c.buildErrorMessage(err, resp), `Failed to bind the instance "%s/%s" to the unit %q`, instance.ServiceName, instance.Name, unit.GetIp()) return log.WrapError(err) } return nil }
func (p *dockerProvisioner) deployPipeline(app provision.App, imageId string, commands []string, w io.Writer) (string, error) { actions := []*action.Action{ &insertEmptyContainerInDB, &createContainer, &startContainer, &updateContainerInDB, &followLogsAndCommit, } pipeline := action.NewPipeline(actions...) buildingImage, err := appNewImageName(app.GetName()) if err != nil { return "", log.WrapError(fmt.Errorf("error getting new image name for app %s", app.GetName())) } args := runContainerActionsArgs{ app: app, imageID: imageId, commands: commands, writer: w, isDeploy: true, buildingImage: buildingImage, provisioner: p, } err = pipeline.Execute(args) if err != nil { log.Errorf("error on execute deploy pipeline for app %s - %s", app.GetName(), err) return "", err } return buildingImage, nil }
func ensureContainersStarted(p DockerProvisioner, w io.Writer, relaunch bool, names []string, nodes ...cluster.Node) error { if w == nil { w = ioutil.Discard } var err error if len(names) == 0 { names, err = nodecontainer.AllNodeContainersNames() if err != nil { return err } } if len(nodes) == 0 { nodes, err = p.Cluster().UnfilteredNodes() if err != nil { return err } } errChan := make(chan error, len(nodes)*len(names)) wg := sync.WaitGroup{} log.Debugf("[node containers] recreating %d containers", len(nodes)*len(names)) recreateContainer := func(node *cluster.Node, confName string) { defer wg.Done() pool := node.Metadata["pool"] containerConfig, confErr := nodecontainer.LoadNodeContainer(pool, confName) if confErr != nil { errChan <- confErr return } if !containerConfig.Valid() { return } log.Debugf("[node containers] recreating container %q in %s [%s]", confName, node.Address, pool) fmt.Fprintf(w, "relaunching node container %q in the node %s [%s]\n", confName, node.Address, pool) confErr = create(containerConfig, node, pool, p, relaunch) if confErr != nil { confErr = errors.Wrapf(confErr, "[node containers] failed to create container in %s [%s]", node.Address, pool) errChan <- log.WrapError(confErr) } } for i := range nodes { wg.Add(1) go func(node *cluster.Node) { defer wg.Done() for j := range names { wg.Add(1) go recreateContainer(node, names[j]) } }(&nodes[i]) } wg.Wait() close(errChan) var allErrors []error for err = range errChan { allErrors = append(allErrors, err) } if len(allErrors) == 0 { return nil } return tsuruErrors.NewMultiError(allErrors...) }
func (c *Client) Create(instance *ServiceInstance, user, requestID string) error { var err error var resp *http.Response params := map[string][]string{ "name": {instance.Name}, "user": {user}, "team": {instance.TeamOwner}, "requestID": {requestID}, } if instance.PlanName != "" { params["plan"] = []string{instance.PlanName} } if instance.Description != "" { params["description"] = []string{instance.Description} } log.Debugf("Attempting to call creation of service instance for %q, params: %#v", instance.ServiceName, params) resp, err = c.issueRequest("/resources", "POST", params) if err == nil { defer resp.Body.Close() if resp.StatusCode < 300 { return nil } if resp.StatusCode == http.StatusConflict { return ErrInstanceAlreadyExistsInAPI } } err = errors.Wrapf(c.buildErrorMessage(err, resp), "Failed to create the instance %s", instance.Name) return log.WrapError(err) }
func (c *Client) Status(instance *ServiceInstance, requestID string) (string, error) { log.Debugf("Attempting to call status of service instance %q at %q api", instance.Name, instance.ServiceName) var ( resp *http.Response err error ) url := "/resources/" + instance.GetIdentifier() + "/status" params := map[string][]string{ "requestID": {requestID}, } if resp, err = c.issueRequest(url, "GET", params); err == nil { defer resp.Body.Close() switch resp.StatusCode { case http.StatusOK: var data []byte data, err = ioutil.ReadAll(resp.Body) return string(data), err case http.StatusAccepted: return "pending", nil case http.StatusNoContent: return "up", nil case http.StatusNotFound: return "not implemented for this service", nil case http.StatusInternalServerError: return "down", nil } } err = errors.Wrapf(c.buildErrorMessage(err, resp), "Failed to get status of instance %s", instance.Name) return "", log.WrapError(err) }
// Commits commits the container, creating an image in Docker. It then returns // the image identifier for usage in future container creation. func (c *Container) Commit(p DockerProvisioner, writer io.Writer) (string, error) { log.Debugf("committing container %s", c.ID) parts := strings.Split(c.BuildingImage, ":") if len(parts) < 2 { return "", log.WrapError(errors.Errorf("error parsing image name, not enough parts: %s", c.BuildingImage)) } repository := strings.Join(parts[:len(parts)-1], ":") tag := parts[len(parts)-1] opts := docker.CommitContainerOptions{Container: c.ID, Repository: repository, Tag: tag} done := p.ActionLimiter().Start(c.HostAddr) image, err := p.Cluster().CommitContainer(opts) done() if err != nil { return "", log.WrapError(errors.Wrapf(err, "error in commit container %s", c.ID)) } imgHistory, err := p.Cluster().ImageHistory(c.BuildingImage) imgSize := "" if err == nil && len(imgHistory) > 0 { fullSize := imgHistory[0].Size if len(imgHistory) > 1 && strings.Contains(imgHistory[1].CreatedBy, "tail -f /dev/null") { fullSize += imgHistory[1].Size } imgSize = fmt.Sprintf("(%.02fMB)", float64(fullSize)/1024/1024) } fmt.Fprintf(writer, " ---> Sending image to repository %s\n", imgSize) log.Debugf("image %s generated from container %s", image.ID, c.ID) maxTry, _ := config.GetInt("docker:registry-max-try") if maxTry <= 0 { maxTry = 3 } for i := 0; i < maxTry; i++ { err = p.PushImage(repository, tag) if err != nil { fmt.Fprintf(writer, "Could not send image, trying again. Original error: %s\n", err.Error()) log.Errorf("error in push image %s: %s", c.BuildingImage, err) time.Sleep(time.Second) continue } break } if err != nil { return "", log.WrapError(errors.Wrapf(err, "error in push image %s", c.BuildingImage)) } return c.BuildingImage, nil }
// Commits commits the container, creating an image in Docker. It then returns // the image identifier for usage in future container creation. func (c *Container) Commit(p DockerProvisioner, writer io.Writer) (string, error) { log.Debugf("commiting container %s", c.ID) parts := strings.Split(c.BuildingImage, ":") if len(parts) < 2 { return "", log.WrapError(fmt.Errorf("error parsing image name, not enough parts: %s", c.BuildingImage)) } repository := strings.Join(parts[:len(parts)-1], ":") tag := parts[len(parts)-1] opts := docker.CommitContainerOptions{Container: c.ID, Repository: repository, Tag: tag} image, err := p.Cluster().CommitContainer(opts) if err != nil { return "", log.WrapError(fmt.Errorf("error in commit container %s: %s", c.ID, err.Error())) } imgData, err := p.Cluster().InspectImage(c.BuildingImage) imgSize := "" if err == nil { imgSize = fmt.Sprintf("(%.02fMB)", float64(imgData.Size)/1024/1024) } fmt.Fprintf(writer, " ---> Sending image to repository %s\n", imgSize) log.Debugf("image %s generated from container %s", image.ID, c.ID) maxTry, _ := config.GetInt("docker:registry-max-try") if maxTry <= 0 { maxTry = 3 } for i := 0; i < maxTry; i++ { err = p.PushImage(repository, tag) if err != nil { fmt.Fprintf(writer, "Could not send image, trying again. Original error: %s\n", err.Error()) log.Errorf("error in push image %s: %s", c.BuildingImage, err.Error()) time.Sleep(time.Second) continue } break } if err != nil { return "", log.WrapError(fmt.Errorf("error in push image %s: %s", c.BuildingImage, err.Error())) } return c.BuildingImage, nil }
func (c *Client) BindApp(instance *ServiceInstance, app bind.App) (map[string]string, error) { log.Debugf("Calling bind of instance %q and %q app at %q API", instance.Name, app.GetName(), instance.ServiceName) var resp *http.Response params := map[string][]string{ "app-host": {app.GetIp()}, } resp, err := c.issueRequest("/resources/"+instance.GetIdentifier()+"/bind-app", "POST", params) if err != nil { return nil, log.WrapError(errors.Wrapf(err, `Failed to bind app %q to service instance "%s/%s"`, app.GetName(), instance.ServiceName, instance.Name)) } defer resp.Body.Close() if resp.StatusCode == http.StatusNotFound { resp, err = c.issueRequest("/resources/"+instance.GetIdentifier()+"/bind", "POST", params) } if err != nil { return nil, log.WrapError(errors.Wrapf(err, `Failed to bind app %q to service instance "%s/%s"`, app.GetName(), instance.ServiceName, instance.Name)) } defer resp.Body.Close() if resp.StatusCode < 300 { var result map[string]string err = c.jsonFromResponse(resp, &result) if err != nil { return nil, err } return result, nil } switch resp.StatusCode { case http.StatusPreconditionFailed: return nil, ErrInstanceNotReady case http.StatusNotFound: return nil, ErrInstanceNotFoundInAPI } err = errors.Wrapf(c.buildErrorMessage(err, resp), `Failed to bind the instance "%s/%s" to the app %q`, instance.ServiceName, instance.Name, app.GetName()) return nil, log.WrapError(err) }
func (c *Client) Destroy(instance *ServiceInstance, requestID string) error { log.Debugf("Attempting to call destroy of service instance %q at %q api", instance.Name, instance.ServiceName) params := map[string][]string{ "requestID": {requestID}, } resp, err := c.issueRequest("/resources/"+instance.GetIdentifier(), "DELETE", params) if err == nil { defer resp.Body.Close() if resp.StatusCode > 299 { if resp.StatusCode == http.StatusNotFound { return ErrInstanceNotFoundInAPI } err = errors.Wrapf(c.buildErrorMessage(err, resp), "Failed to destroy the instance %s", instance.Name) return log.WrapError(err) } } return err }
func (c *Client) UnbindApp(instance *ServiceInstance, app bind.App) error { log.Debugf("Calling unbind of service instance %q and app %q at %q", instance.Name, app.GetName(), instance.ServiceName) var resp *http.Response url := "/resources/" + instance.GetIdentifier() + "/bind-app" params := map[string][]string{ "app-host": {app.GetIp()}, } resp, err := c.issueRequest(url, "DELETE", params) if err == nil { defer resp.Body.Close() if resp.StatusCode > 299 { if resp.StatusCode == http.StatusNotFound { return ErrInstanceNotFoundInAPI } err = errors.Wrapf(c.buildErrorMessage(err, resp), "Failed to unbind (%q)", url) return log.WrapError(err) } } return err }