960f3be76c
The interesting decision in this commit was to expose AR's state and not a fully materialized Allocation struct. AR.clientAlloc builds an Alloc that contains the task state, so I considered simply memoizing and exposing that method. However, that would lead to AR having two awkwardly similar methods: - Alloc() - which returns the server-sent alloc - ClientAlloc() - which returns the fully materialized client alloc Since ClientAlloc() could be memoized it would be just as cheap to call as Alloc(), so why not replace Alloc() entirely? Replacing Alloc() entirely would require Update() to immediately materialize the task states on server-sent Allocs as there may have been local task state changes since the server received an Alloc update. This quickly becomes difficult to reason about: should Update hooks use the TaskStates? Are state changes caused by TR Update hooks immediately reflected in the Alloc? Should AR persist its copy of the Alloc? If so, are its TaskStates canonical or the TaskStates on TR? So! Forget that. Let's separate the static Allocation from the dynamic AR & TR state! - AR.Alloc() is for static Allocation access (often for the Job) - AR.AllocState() is for the dynamic AR & TR runtime state (deployment status, task states, etc). If code needs to know the status of a task: AllocState() If code needs to know the names of tasks: Alloc() It should be very easy for a developer to reason about which method they should call and what they can do with the return values.
53 lines
1.8 KiB
Go
53 lines
1.8 KiB
Go
package agent
|
|
|
|
// rpcHandlerForAlloc is a helper that given an allocation ID returns whether to
|
|
// use the local clients RPC, the local clients remote RPC or the server on the
|
|
// agent.
|
|
func (s *HTTPServer) rpcHandlerForAlloc(allocID string) (localClient, remoteClient, server bool) {
|
|
c := s.agent.Client()
|
|
srv := s.agent.Server()
|
|
|
|
// See if the local client can handle the request.
|
|
localAlloc := false
|
|
if c != nil {
|
|
// If there is an error it means that the client doesn't have the
|
|
// allocation so we can't use the local client
|
|
_, err := c.GetAllocState(allocID)
|
|
if err == nil {
|
|
localAlloc = true
|
|
}
|
|
}
|
|
|
|
// Only use the client RPC to server if we don't have a server and the local
|
|
// client can't handle the call.
|
|
useClientRPC := c != nil && !localAlloc && srv == nil
|
|
|
|
// Use the server as a last case.
|
|
useServerRPC := !localAlloc && !useClientRPC && srv != nil
|
|
|
|
return localAlloc, useClientRPC, useServerRPC
|
|
}
|
|
|
|
// rpcHandlerForNode is a helper that given a node ID returns whether to
|
|
// use the local clients RPC, the local clients remote RPC or the server on the
|
|
// agent. If there is a local node and no node id is given, it is assumed the
|
|
// local node is being targed.
|
|
func (s *HTTPServer) rpcHandlerForNode(nodeID string) (localClient, remoteClient, server bool) {
|
|
c := s.agent.Client()
|
|
srv := s.agent.Server()
|
|
|
|
// See if the local client can handle the request.
|
|
localClient = c != nil && // Must have a client
|
|
(nodeID == "" || // If no node ID is given
|
|
nodeID == c.NodeID()) // Requested node is the local node.
|
|
|
|
// Only use the client RPC to server if we don't have a server and the local
|
|
// client can't handle the call.
|
|
useClientRPC := c != nil && !localClient && srv == nil
|
|
|
|
// Use the server as a last case.
|
|
useServerRPC := !localClient && !useClientRPC && srv != nil && nodeID != ""
|
|
|
|
return localClient, useClientRPC, useServerRPC
|
|
}
|