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
}