func newUaaClient(logger lager.Logger, clock clock.Clock, c *config.Config) uaa_client.Client { if c.RoutingApi.AuthDisabled { logger.Info("using-noop-token-fetcher") return uaa_client.NewNoOpUaaClient() } if c.OAuth.Port == -1 { logger.Fatal("tls-not-enabled", errors.New("GoRouter requires TLS enabled to get OAuth token"), lager.Data{"token-endpoint": c.OAuth.TokenEndpoint, "port": c.OAuth.Port}) } tokenURL := fmt.Sprintf("https://%s:%d", c.OAuth.TokenEndpoint, c.OAuth.Port) cfg := &uaa_config.Config{ UaaEndpoint: tokenURL, SkipVerification: c.OAuth.SkipSSLValidation, ClientName: c.OAuth.ClientName, ClientSecret: c.OAuth.ClientSecret, CACerts: c.OAuth.CACerts, MaxNumberOfRetries: c.TokenFetcherMaxRetries, RetryInterval: c.TokenFetcherRetryInterval, ExpirationBufferInSec: c.TokenFetcherExpirationBufferTimeInSeconds, } uaaClient, err := uaa_client.NewClient(logger, cfg, clock) if err != nil { logger.Fatal("initialize-token-fetcher-error", err) } return uaaClient }
// RemoveDesiredLRP deletes the DesiredLRPSchedulingInfo and the DesiredLRPRunInfo // from the database. We delete DesiredLRPSchedulingInfo first because the system // uses it to determine wheter the lrp is present. In the event that only the // RunInfo fails to delete, the orphaned DesiredLRPRunInfo will be garbage // collected later by convergence. func (db *ETCDDB) RemoveDesiredLRP(logger lager.Logger, processGuid string) error { logger = logger.WithData(lager.Data{"process_guid": processGuid}) logger.Info("starting") defer logger.Info("complete") _, schedulingInfoErr := db.client.Delete(DesiredLRPSchedulingInfoSchemaPath(processGuid), true) schedulingInfoErr = ErrorFromEtcdError(logger, schedulingInfoErr) if schedulingInfoErr != nil && schedulingInfoErr != models.ErrResourceNotFound { logger.Error("failed-deleting-scheduling-info", schedulingInfoErr) return schedulingInfoErr } _, runInfoErr := db.client.Delete(DesiredLRPRunInfoSchemaPath(processGuid), true) runInfoErr = ErrorFromEtcdError(logger, runInfoErr) if runInfoErr != nil && runInfoErr != models.ErrResourceNotFound { logger.Error("failed-deleting-run-info", runInfoErr) return runInfoErr } if schedulingInfoErr == models.ErrResourceNotFound && runInfoErr == models.ErrResourceNotFound { // If neither component of the desired LRP exists, don't bother trying to delete running instances return models.ErrResourceNotFound } return nil }
func (db *serviceClient) CellEvents(logger lager.Logger) <-chan models.CellEvent { logger = logger.Session("cell-events") disappearanceWatcher, disappeared := locket.NewDisappearanceWatcher(logger, db.consulClient, CellSchemaRoot(), db.clock) process := ifrit.Invoke(disappearanceWatcher) events := make(chan models.CellEvent) go func() { for { select { case keys, ok := <-disappeared: if !ok { process.Signal(os.Interrupt) return } cellIDs := make([]string, len(keys)) for i, key := range keys { cellIDs[i] = path.Base(key) } logger.Info("cell-disappeared", lager.Data{"cell_ids": cellIDs}) events <- models.NewCellDisappearedEvent(cellIDs) } } }() return events }
func (r *driverSyncer) Discover(logger lager.Logger) (map[string]voldriver.Driver, error) { logger = logger.Session("discover") logger.Debug("start") logger.Info(fmt.Sprintf("Discovering drivers in %s", r.driverPaths)) defer logger.Debug("end") endpoints := make(map[string]voldriver.Driver) for _, driverPath := range r.driverPaths { //precedence order: sock -> spec -> json spec_types := [3]string{"sock", "spec", "json"} for _, spec_type := range spec_types { matchingDriverSpecs, err := r.getMatchingDriverSpecs(logger, driverPath, spec_type) if err != nil { // untestable on linux, does glob work differently on windows??? return map[string]voldriver.Driver{}, fmt.Errorf("Volman configured with an invalid driver path '%s', error occured list files (%s)", driverPath, err.Error()) } if len(matchingDriverSpecs) > 0 { logger.Debug("driver-specs", lager.Data{"drivers": matchingDriverSpecs}) endpoints = r.insertIfAliveAndNotFound(logger, endpoints, driverPath, matchingDriverSpecs) } } } return endpoints, nil }
func (r *execPreparer) Prepare(log lager.Logger, bundlePath string, spec garden.ProcessSpec) (*PreparedSpec, error) { log = log.Session("prepare") log.Info("start") defer log.Info("finished") bndl, err := r.bundleLoader.Load(bundlePath) if err != nil { log.Error("load-bundle-failed", err) return nil, err } pidBytes, err := ioutil.ReadFile(filepath.Join(bundlePath, "pidfile")) if err != nil { log.Error("read-pidfile-failed", err) return nil, err } pid := string(pidBytes) rootFsPath := filepath.Join("/proc", pid, "root") u, err := r.lookupUser(bndl, rootFsPath, spec.User) if err != nil { log.Error("lookup-user-failed", err) return nil, err } cwd := u.home if spec.Dir != "" { cwd = spec.Dir } if err := r.ensureDirExists(rootFsPath, cwd, u.hostUid, u.hostGid); err != nil { log.Error("ensure-dir-failed", err) return nil, err } caps := bndl.Capabilities() if u.containerUid != 0 { caps = intersect(caps, r.nonRootMaxCaps) } return &PreparedSpec{ HostUID: u.hostUid, HostGID: u.hostGid, Process: specs.Process{ Args: append([]string{spec.Path}, spec.Args...), Env: envFor(u.containerUid, bndl, spec), User: specs.User{ UID: uint32(u.containerUid), GID: uint32(u.containerGid), AdditionalGids: []uint32{}, }, Cwd: cwd, Capabilities: caps, Rlimits: toRlimits(spec.Limits), Terminal: spec.TTY != nil, ApparmorProfile: bndl.Process().ApparmorProfile, }, }, nil }
func (c *Creator) Create(log lager.Logger, bundlePath, id string, _ garden.ProcessIO) (theErr error) { log = log.Session("create", lager.Data{"bundle": bundlePath}) defer log.Info("finished") logFilePath := filepath.Join(bundlePath, "create.log") pidFilePath := filepath.Join(bundlePath, "pidfile") cmd := exec.Command(c.runcPath, "--debug", "--log", logFilePath, "create", "--no-new-keyring", "--bundle", bundlePath, "--pid-file", pidFilePath, id) log.Info("creating", lager.Data{ "runc": c.runcPath, "bundlePath": bundlePath, "id": id, "logPath": logFilePath, "pidFilePath": pidFilePath, }) err := c.commandRunner.Run(cmd) defer func() { theErr = processLogs(log, logFilePath, err) }() return }
func connectToNatsServer(logger lager.Logger, c *config.Config, startMsg chan<- struct{}) *nats.Conn { var natsClient *nats.Conn var natsHost atomic.Value var err error options := natsOptions(logger, c, &natsHost, startMsg) attempts := 3 for attempts > 0 { natsClient, err = options.Connect() if err == nil { break } else { attempts-- time.Sleep(100 * time.Millisecond) } } if err != nil { logger.Fatal("nats-connection-error", err) } var natsHostStr string natsUrl, err := url.Parse(natsClient.ConnectedUrl()) if err == nil { natsHostStr = natsUrl.Host } logger.Info("Successfully-connected-to-nats", lager.Data{"host": natsHostStr}) natsHost.Store(natsHostStr) return natsClient }
func (e *IncreaseRunInfoColumnSize) Up(logger lager.Logger) error { logger = logger.Session("increase-run-info-column") logger.Info("starting") defer logger.Info("completed") return alterTables(logger, e.rawSQLDB, e.dbFlavor) }
func HandleCompletedTask(logger lager.Logger, httpClient *http.Client, taskDB db.TaskDB, task *models.Task) { logger = logger.Session("handle-completed-task", lager.Data{"task_guid": task.TaskGuid}) if task.CompletionCallbackUrl != "" { modelErr := taskDB.ResolvingTask(logger, task.TaskGuid) if modelErr != nil { logger.Error("marking-task-as-resolving-failed", modelErr) return } logger = logger.WithData(lager.Data{"callback_url": task.CompletionCallbackUrl}) json, err := json.Marshal(&models.TaskCallbackResponse{ TaskGuid: task.TaskGuid, Failed: task.Failed, FailureReason: task.FailureReason, Result: task.Result, Annotation: task.Annotation, CreatedAt: task.CreatedAt, }) if err != nil { logger.Error("marshalling-task-failed", err) return } var statusCode int for i := 0; i < MAX_CB_RETRIES; i++ { request, err := http.NewRequest("POST", task.CompletionCallbackUrl, bytes.NewReader(json)) if err != nil { logger.Error("building-request-failed", err) return } request.Header.Set("Content-Type", "application/json") response, err := httpClient.Do(request) if err != nil { matched, _ := regexp.MatchString("Client.Timeout|use of closed network connection", err.Error()) if matched { continue } logger.Error("doing-request-failed", err) return } defer response.Body.Close() statusCode = response.StatusCode if shouldResolve(statusCode) { modelErr := taskDB.DeleteTask(logger, task.TaskGuid) if modelErr != nil { logger.Error("delete-task-failed", modelErr) } return } } logger.Info("callback-failed", lager.Data{"status_code": statusCode}) } return }
func (db *SQLDB) CompleteTask(logger lager.Logger, taskGuid, cellID string, failed bool, failureReason, taskResult string) (*models.Task, error) { logger = logger.Session("complete-task", lager.Data{"task_guid": taskGuid, "cell_id": cellID}) logger.Info("starting") defer logger.Info("complete") var task *models.Task err := db.transact(logger, func(logger lager.Logger, tx *sql.Tx) error { var err error task, err = db.fetchTaskForUpdate(logger, taskGuid, tx) if err != nil { logger.Error("failed-locking-task", err) return err } if task.CellId != cellID && task.State == models.Task_Running { logger.Error("failed-task-already-running-on-different-cell", err) return models.NewRunningOnDifferentCellError(cellID, task.CellId) } if err = task.ValidateTransitionTo(models.Task_Completed); err != nil { logger.Error("failed-to-transition-task-to-completed", err) return err } return db.completeTask(logger, task, failed, failureReason, taskResult, tx) }) return task, err }
func (r *remoteClient) Unmount(logger lager.Logger, driverId string, volumeId string) error { logger = logger.Session("mount") logger.Info("start") defer logger.Info("end") unmountRequest := volman.UnmountRequest{driverId, volumeId} payload, err := json.Marshal(unmountRequest) if err != nil { return r.clientError(logger, err, fmt.Sprintf("Error marshalling JSON request %#v", unmountRequest)) } request, err := r.reqGen.CreateRequest(volman.UnmountRoute, nil, bytes.NewReader(payload)) if err != nil { return r.clientError(logger, err, fmt.Sprintf("Error creating request to %s", volman.UnmountRoute)) } response, err := r.HttpClient.Do(request) if err != nil { return r.clientError(logger, err, fmt.Sprintf("Error unmounting volume %s", volumeId)) } if response.StatusCode == 500 { var remoteError volman.Error if err := unmarshallJSON(logger, response.Body, &remoteError); err != nil { return r.clientError(logger, err, fmt.Sprintf("Error parsing 500 response from %s", volman.UnmountRoute)) } return remoteError } return nil }
func (db *SQLDB) DesireTask(logger lager.Logger, taskDef *models.TaskDefinition, taskGuid, domain string) error { logger = logger.Session("desire-task", lager.Data{"task_guid": taskGuid}) logger.Info("starting") defer logger.Info("complete") taskDefData, err := db.serializeModel(logger, taskDef) if err != nil { logger.Error("failed-serializing-task-definition", err) return err } return db.transact(logger, func(logger lager.Logger, tx *sql.Tx) error { now := db.clock.Now().UnixNano() _, err = db.insert(logger, tx, tasksTable, SQLAttributes{ "guid": taskGuid, "domain": domain, "created_at": now, "updated_at": now, "first_completed_at": 0, "state": models.Task_Pending, "task_definition": taskDefData, }, ) if err != nil { logger.Error("failed-inserting-task", err) return db.convertSQLError(err) } return nil }) }
func (db *ETCDDB) ConvergeLRPs(logger lager.Logger, cellSet models.CellSet) ([]*auctioneer.LRPStartRequest, []*models.ActualLRPKeyWithSchedulingInfo, []*models.ActualLRPKey) { convergeStart := db.clock.Now() convergeLRPRunsCounter.Increment() logger = logger.Session("etcd") logger.Info("starting-convergence") defer logger.Info("finished-convergence") defer func() { err := convergeLRPDuration.Send(time.Since(convergeStart)) if err != nil { logger.Error("failed-sending-converge-lrp-duration-metric", err) } }() logger.Debug("gathering-convergence-input") input, err := db.GatherAndPruneLRPs(logger, cellSet) if err != nil { logger.Error("failed-gathering-convergence-input", err) return nil, nil, nil } logger.Debug("succeeded-gathering-convergence-input") changes := CalculateConvergence(logger, db.clock, models.NewDefaultRestartCalculator(), input) return db.ResolveConvergence(logger, input.DesiredLRPs, changes) }
func (db *ETCDDB) batchDeleteNodes(keys []string, logger lager.Logger) { if len(keys) == 0 { return } works := []func(){} for _, key := range keys { key := key works = append(works, func() { logger.Info("deleting", lager.Data{"key": key}) _, err := db.client.Delete(key, true) if err != nil { logger.Error("failed-to-delete", err, lager.Data{ "key": key, }) } }) } throttler, err := workpool.NewThrottler(db.convergenceWorkersSize, works) if err != nil { logger.Error("failed-to-create-throttler", err) } throttler.Work() return }
func (db *SQLDB) DeleteTask(logger lager.Logger, taskGuid string) error { logger = logger.Session("delete-task", lager.Data{"task_guid": taskGuid}) logger.Info("starting") defer logger.Info("complete") return db.transact(logger, func(logger lager.Logger, tx *sql.Tx) error { task, err := db.fetchTaskForUpdate(logger, taskGuid, tx) if err != nil { logger.Error("failed-locking-task", err) return err } if task.State != models.Task_Resolving { err = models.NewTaskTransitionError(task.State, models.Task_Resolving) logger.Error("invalid-state-transition", err) return err } _, err = db.delete(logger, tx, tasksTable, "guid = ?", taskGuid) if err != nil { logger.Error("failed-deleting-task", err) return db.convertSQLError(err) } return nil }) }
// Create creates a bundle in the depot and starts its init process func (c *Containerizer) Create(log lager.Logger, spec gardener.DesiredContainerSpec) error { log = log.Session("containerizer-create", lager.Data{"handle": spec.Handle}) log.Info("start") defer log.Info("finished") if err := c.depot.Create(log, spec.Handle, c.bundler.Generate(spec)); err != nil { log.Error("depot-create-failed", err) return err } path, err := c.depot.Lookup(log, spec.Handle) if err != nil { log.Error("lookup-failed", err) return err } if err = c.runtime.Create(log, path, spec.Handle, garden.ProcessIO{}); err != nil { log.Error("runtime-create-failed", err) return err } go func() { if err := c.runtime.WatchEvents(log, spec.Handle, c.events); err != nil { log.Error("watch-failed", err) } }() return nil }
// The cell calls this when it has finished running the task (be it success or failure) // stagerTaskBBS will retry this repeatedly if it gets a StoreTimeout error (up to N seconds?) // This really really shouldn't fail. If it does, blog about it and walk away. If it failed in a // consistent way (i.e. key already exists), there's probably a flaw in our design. func (db *ETCDDB) CompleteTask(logger lager.Logger, taskGuid, cellId string, failed bool, failureReason, result string) (*models.Task, error) { logger = logger.WithData(lager.Data{"task_guid": taskGuid, "cell_id": cellId}) logger.Info("starting") defer logger.Info("finished") task, index, err := db.taskByGuidWithIndex(logger, taskGuid) if err != nil { logger.Error("failed-getting-task", err) return nil, err } if task.State == models.Task_Running && task.CellId != cellId { err = models.NewRunningOnDifferentCellError(cellId, task.CellId) logger.Error("invalid-cell-id", err) return nil, err } if err = task.ValidateTransitionTo(models.Task_Completed); err != nil { logger.Error("invalid-state-transition", err) return nil, err } return task, db.completeTask(logger, task, index, failed, failureReason, result) }
// The stager calls this when it wants to claim a completed task. This ensures that only one // stager ever attempts to handle a completed task func (db *ETCDDB) ResolvingTask(logger lager.Logger, taskGuid string) error { logger = logger.WithData(lager.Data{"task_guid": taskGuid}) logger.Info("starting") defer logger.Info("finished") task, index, err := db.taskByGuidWithIndex(logger, taskGuid) if err != nil { logger.Error("failed-getting-task", err) return err } err = task.ValidateTransitionTo(models.Task_Resolving) if err != nil { logger.Error("invalid-state-transition", err) return err } task.UpdatedAt = db.clock.Now().UnixNano() task.State = models.Task_Resolving value, err := db.serializeModel(logger, task) if err != nil { return err } _, err = db.client.CompareAndSwap(TaskSchemaPathByGuid(taskGuid), value, NO_TTL, index) if err != nil { return ErrorFromEtcdError(logger, err) } return nil }
func (r *RootfsWriter) writeFile(log lager.Logger, filePath string, contents []byte, rootfs string, uid, gid int) error { log = log.Session("rootfs-write-file", lager.Data{ "rootfs": rootfs, "path": filePath, "rootUid": uid, "rootGit": gid, }) log.Info("write") dir := filepath.Dir(filePath) if _, err := os.Lstat(dir); os.IsNotExist(err) { os.Mkdir(dir, 0755) } file, err := os.Create(filePath) if err != nil { log.Error("creating-file", err) return err } defer file.Close() if _, err := file.Write(contents); err != nil { log.Error("writting-file", err) return err } if err := os.Chown(filePath, uid, gid); err != nil { log.Error("chowing-file", err) return err } log.Info("written") return nil }
func (r *registrationRunner) waitForSignal(logger lager.Logger, signals <-chan os.Signal) error { agent := r.consulClient.Agent() <-signals logger.Info("deregistering-service") return agent.ServiceDeregister(r.registration.ID) }
func newUnmountHandler(logger lager.Logger, client volman.Manager) http.HandlerFunc { return func(w http.ResponseWriter, req *http.Request) { logger := logger.Session("unmount") logger.Info("start") defer logger.Info("end") body, err := ioutil.ReadAll(req.Body) if err != nil { respondWithError(logger, "Error reading unmount request body", err, w) return } var unmountRequest volman.UnmountRequest if err = json.Unmarshal(body, &unmountRequest); err != nil { respondWithError(logger, fmt.Sprintf("Error reading unmount request body: %#v", body), err, w) return } err = client.Unmount(logger, unmountRequest.DriverId, unmountRequest.VolumeId) if err != nil { respondWithError(logger, fmt.Sprintf("Error unmounting volume %s with driver %s", unmountRequest.VolumeId, unmountRequest.DriverId), err, w) return } cf_http_handlers.WriteJSONResponse(w, http.StatusOK, struct{}{}) } }
func (db *ETCDDB) FailActualLRP(logger lager.Logger, key *models.ActualLRPKey, errorMessage string) (*models.ActualLRPGroup, *models.ActualLRPGroup, error) { logger = logger.WithData(lager.Data{"actual_lrp_key": key, "error_message": errorMessage}) logger.Info("starting") lrp, prevIndex, err := db.rawActualLRPByProcessGuidAndIndex(logger, key.ProcessGuid, key.Index) if err != nil { logger.Error("failed-to-get-actual-lrp", err) return nil, nil, err } beforeActualLRP := *lrp if lrp.State != models.ActualLRPStateUnclaimed { return nil, nil, models.ErrActualLRPCannotBeFailed } lrp.ModificationTag.Increment() lrp.PlacementError = errorMessage lrp.Since = db.clock.Now().UnixNano() lrpData, serialErr := db.serializeModel(logger, lrp) if serialErr != nil { return nil, nil, serialErr } _, err = db.client.CompareAndSwap(ActualLRPSchemaPath(key.ProcessGuid, key.Index), lrpData, 0, prevIndex) if err != nil { logger.Error("failed", err) return nil, nil, models.ErrActualLRPCannotBeFailed } logger.Info("succeeded") return &models.ActualLRPGroup{Instance: &beforeActualLRP}, &models.ActualLRPGroup{Instance: lrp}, nil }
func (db *SQLDB) ConvergeLRPs(logger lager.Logger, cellSet models.CellSet) ([]*auctioneer.LRPStartRequest, []*models.ActualLRPKeyWithSchedulingInfo, []*models.ActualLRPKey) { convergeStart := db.clock.Now() convergeLRPRunsCounter.Increment() logger.Info("starting") defer logger.Info("completed") defer func() { err := convergeLRPDuration.Send(time.Since(convergeStart)) if err != nil { logger.Error("failed-sending-converge-lrp-duration-metric", err) } }() now := db.clock.Now() db.pruneDomains(logger, now) db.pruneEvacuatingActualLRPs(logger, now) domainSet, err := db.domainSet(logger) if err != nil { return nil, nil, nil } db.emitDomainMetrics(logger, domainSet) converge := newConvergence(db) converge.staleUnclaimedActualLRPs(logger, now) converge.actualLRPsWithMissingCells(logger, cellSet) converge.lrpInstanceCounts(logger, domainSet) converge.orphanedActualLRPs(logger) converge.crashedActualLRPs(logger, now) return converge.result(logger) }
func (db *SQLDB) FailTask(logger lager.Logger, taskGuid, failureReason string) (*models.Task, error) { logger = logger.Session("fail-task", lager.Data{"task_guid": taskGuid}) logger.Info("starting") defer logger.Info("complete") var task *models.Task err := db.transact(logger, func(logger lager.Logger, tx *sql.Tx) error { var err error task, err = db.fetchTaskForUpdate(logger, taskGuid, tx) if err != nil { logger.Error("failed-locking-task", err) return err } if err = task.ValidateTransitionTo(models.Task_Completed); err != nil { if task.State != models.Task_Pending { logger.Error("failed-to-transition-task-to-completed", err) return err } } return db.completeTask(logger, task, true, failureReason, "", tx) }) return task, err }
func (db *ETCDDB) DesireTask(logger lager.Logger, taskDef *models.TaskDefinition, taskGuid, domain string) error { logger = logger.WithData(lager.Data{"task_guid": taskGuid}) logger.Info("starting") defer logger.Info("finished") now := db.clock.Now().UnixNano() task := &models.Task{ TaskDefinition: taskDef, TaskGuid: taskGuid, Domain: domain, State: models.Task_Pending, CreatedAt: now, UpdatedAt: now, } value, err := db.serializeModel(logger, task) if err != nil { return err } logger.Debug("persisting-task") _, err = db.client.Create(TaskSchemaPathByGuid(task.TaskGuid), value, NO_TTL) if err != nil { return ErrorFromEtcdError(logger, err) } logger.Debug("succeeded-persisting-task") return nil }
// The stager calls this when it wants to claim a completed task. This ensures that only one // stager ever attempts to handle a completed task func (db *SQLDB) ResolvingTask(logger lager.Logger, taskGuid string) error { logger = logger.WithData(lager.Data{"task_guid": taskGuid}) logger.Info("starting") defer logger.Info("complete") return db.transact(logger, func(logger lager.Logger, tx *sql.Tx) error { task, err := db.fetchTaskForUpdate(logger, taskGuid, tx) if err != nil { logger.Error("failed-locking-task", err) return err } if err = task.ValidateTransitionTo(models.Task_Resolving); err != nil { logger.Error("invalid-state-transition", err) return err } now := db.clock.Now().UnixNano() _, err = db.update(logger, tx, tasksTable, SQLAttributes{ "state": models.Task_Resolving, "updated_at": now, }, "guid = ?", taskGuid, ) if err != nil { logger.Error("failed-updating-tasks", err) return db.convertSQLError(err) } return nil }) }
func (client *localClient) Unmount(logger lager.Logger, driverId string, volumeName string) error { logger = logger.Session("unmount") logger.Info("start") defer logger.Info("end") logger.Debug("unmounting-volume", lager.Data{"volumeName": volumeName}) unmountStart := client.clock.Now() defer func() { sendUnmountDurationMetrics(logger, time.Since(unmountStart), driverId) }() driver, found := client.driverRegistry.Driver(driverId) if !found { err := errors.New("Driver '" + driverId + "' not found in list of known drivers") logger.Error("mount-driver-lookup-error", err) volmanUnmountErrorsCounter.Increment() return err } env := driverhttp.NewHttpDriverEnv(logger, context.TODO()) if response := driver.Unmount(env, voldriver.UnmountRequest{Name: volumeName}); response.Err != "" { err := errors.New(response.Err) logger.Error("unmount-failed", err) volmanUnmountErrorsCounter.Increment() return err } return nil }
func (h *EvacuationHandler) RemoveEvacuatingActualLRP(logger lager.Logger, w http.ResponseWriter, req *http.Request) { var err error logger = logger.Session("remove-evacuating-actual-lrp") logger.Info("started") defer logger.Info("completed") request := &models.RemoveEvacuatingActualLRPRequest{} response := &models.RemoveEvacuatingActualLRPResponse{} defer func() { exitIfUnrecoverable(logger, h.exitChan, response.Error) }() defer writeResponse(w, response) err = parseRequest(logger, req, request) if err != nil { response.Error = models.ConvertError(err) return } beforeActualLRPGroup, err := h.actualLRPDB.ActualLRPGroupByProcessGuidAndIndex(logger, request.ActualLrpKey.ProcessGuid, request.ActualLrpKey.Index) if err != nil { response.Error = models.ConvertError(err) return } err = h.db.RemoveEvacuatingActualLRP(logger, request.ActualLrpKey, request.ActualLrpInstanceKey) if err != nil { response.Error = models.ConvertError(err) return } go h.actualHub.Emit(models.NewActualLRPRemovedEvent(beforeActualLRPGroup)) }
func (d *DirectoryDepot) Destroy(log lager.Logger, handle string) error { log = log.Session("destroy", lager.Data{"handle": handle}) log.Info("started") defer log.Info("finished") return os.RemoveAll(d.toDir(handle)) }
func (db *SQLDB) fetchTask(logger lager.Logger, scanner RowScanner, tx Queryable) (*models.Task, error) { var guid, domain, cellID, failureReason string var result sql.NullString var createdAt, updatedAt, firstCompletedAt int64 var state int32 var failed bool var taskDefData []byte err := scanner.Scan( &guid, &domain, &updatedAt, &createdAt, &firstCompletedAt, &state, &cellID, &result, &failed, &failureReason, &taskDefData, ) if err == sql.ErrNoRows { return nil, models.ErrResourceNotFound } if err != nil { logger.Error("failed-scanning-row", err) return nil, err } var taskDef models.TaskDefinition err = db.deserializeModel(logger, taskDefData, &taskDef) if err != nil { logger.Info("deleting-malformed-task-from-db", lager.Data{"guid": guid}) _, err = db.delete(logger, tx, tasksTable, "guid = ?", guid) if err != nil { logger.Error("failed-deleting-task", err) return nil, db.convertSQLError(err) } return nil, models.ErrDeserialize } task := &models.Task{ TaskGuid: guid, Domain: domain, CreatedAt: createdAt, UpdatedAt: updatedAt, FirstCompletedAt: firstCompletedAt, State: models.Task_State(state), CellId: cellID, Result: result.String, Failed: failed, FailureReason: failureReason, TaskDefinition: &taskDef, } return task, nil }