github.com/anth0d/nomad@v0.0.0-20221214183521-ae3a0a2cad06/client/allocrunner/taskrunner/task_runner_getters.go (about)

     1  package taskrunner
     2  
     3  import (
     4  	"github.com/hashicorp/nomad/client/allocrunner/taskrunner/state"
     5  	"github.com/hashicorp/nomad/nomad/structs"
     6  )
     7  
     8  func (tr *TaskRunner) Alloc() *structs.Allocation {
     9  	tr.allocLock.Lock()
    10  	defer tr.allocLock.Unlock()
    11  	return tr.alloc
    12  }
    13  
    14  // setAlloc and task on TaskRunner
    15  func (tr *TaskRunner) setAlloc(updated *structs.Allocation, task *structs.Task) {
    16  	tr.allocLock.Lock()
    17  	defer tr.allocLock.Unlock()
    18  
    19  	tr.taskLock.Lock()
    20  	defer tr.taskLock.Unlock()
    21  
    22  	tr.alloc = updated
    23  	tr.task = task
    24  }
    25  
    26  // IsLeader returns true if this task is the leader of its task group.
    27  func (tr *TaskRunner) IsLeader() bool {
    28  	return tr.taskLeader
    29  }
    30  
    31  // IsPoststopTask returns true if this task is a poststop task in its task group.
    32  func (tr *TaskRunner) IsPoststopTask() bool {
    33  	return tr.Task().Lifecycle != nil && tr.Task().Lifecycle.Hook == structs.TaskLifecycleHookPoststop
    34  }
    35  
    36  // IsSidecarTask returns true if this task is a sidecar task in its task group.
    37  func (tr *TaskRunner) IsSidecarTask() bool {
    38  	return tr.Task().Lifecycle != nil && tr.Task().Lifecycle.Sidecar
    39  }
    40  
    41  func (tr *TaskRunner) Task() *structs.Task {
    42  	tr.taskLock.RLock()
    43  	defer tr.taskLock.RUnlock()
    44  	return tr.task
    45  }
    46  
    47  func (tr *TaskRunner) TaskState() *structs.TaskState {
    48  	tr.stateLock.Lock()
    49  	defer tr.stateLock.Unlock()
    50  	return tr.state.Copy()
    51  }
    52  
    53  func (tr *TaskRunner) getVaultToken() string {
    54  	tr.vaultTokenLock.Lock()
    55  	defer tr.vaultTokenLock.Unlock()
    56  	return tr.vaultToken
    57  }
    58  
    59  // setVaultToken updates the vault token on the task runner as well as in the
    60  // task's environment. These two places must be set atomically to avoid a task
    61  // seeing a different token on the task runner and in its environment.
    62  func (tr *TaskRunner) setVaultToken(token string) {
    63  	tr.vaultTokenLock.Lock()
    64  	defer tr.vaultTokenLock.Unlock()
    65  
    66  	// Update the Vault token on the runner
    67  	tr.vaultToken = token
    68  
    69  	// Update the task's environment
    70  	taskNamespace := tr.task.Vault.Namespace
    71  
    72  	ns := tr.clientConfig.VaultConfig.Namespace
    73  	if taskNamespace != "" {
    74  		ns = taskNamespace
    75  	}
    76  	tr.envBuilder.SetVaultToken(token, ns, tr.task.Vault.Env)
    77  }
    78  
    79  func (tr *TaskRunner) getNomadToken() string {
    80  	tr.nomadTokenLock.Lock()
    81  	defer tr.nomadTokenLock.Unlock()
    82  	return tr.nomadToken
    83  }
    84  
    85  func (tr *TaskRunner) setNomadToken(token string) {
    86  	tr.nomadTokenLock.Lock()
    87  	defer tr.nomadTokenLock.Unlock()
    88  	tr.nomadToken = token
    89  }
    90  
    91  // getDriverHandle returns a driver handle.
    92  func (tr *TaskRunner) getDriverHandle() *DriverHandle {
    93  	tr.handleLock.Lock()
    94  	defer tr.handleLock.Unlock()
    95  	return tr.handle
    96  }
    97  
    98  // setDriverHandle sets the driver handle and updates the driver network in the
    99  // task's environment.
   100  func (tr *TaskRunner) setDriverHandle(handle *DriverHandle) {
   101  	tr.handleLock.Lock()
   102  	defer tr.handleLock.Unlock()
   103  	tr.handle = handle
   104  
   105  	// Update the environment's driver network
   106  	tr.envBuilder.SetDriverNetwork(handle.net)
   107  }
   108  
   109  func (tr *TaskRunner) clearDriverHandle() {
   110  	tr.handleLock.Lock()
   111  	defer tr.handleLock.Unlock()
   112  	if tr.handle != nil {
   113  		tr.driver.DestroyTask(tr.handle.ID(), true)
   114  	}
   115  	tr.handle = nil
   116  }
   117  
   118  // setKillErr stores any error that arouse while killing the task
   119  func (tr *TaskRunner) setKillErr(err error) {
   120  	tr.killErrLock.Lock()
   121  	defer tr.killErrLock.Unlock()
   122  	tr.killErr = err
   123  }
   124  
   125  // getKillErr returns any error that arouse while killing the task
   126  func (tr *TaskRunner) getKillErr() error {
   127  	tr.killErrLock.Lock()
   128  	defer tr.killErrLock.Unlock()
   129  	return tr.killErr
   130  }
   131  
   132  // hookState returns the state for the given hook or nil if no state is
   133  // persisted for the hook.
   134  func (tr *TaskRunner) hookState(name string) *state.HookState {
   135  	tr.stateLock.RLock()
   136  	defer tr.stateLock.RUnlock()
   137  
   138  	var s *state.HookState
   139  	if tr.localState.Hooks != nil {
   140  		s = tr.localState.Hooks[name].Copy()
   141  	}
   142  	return s
   143  }