// setHAStatus tells the engine what the current HA status is.
183582
func (e *Engine) setHAStatus(status seesaw.HAStatus) {
	e.haManager.statusChan <- status
}
577259
func (c *configV8) setHost(alias string, cfg hostConfigV8) {
	if _, ok := c.Hosts[alias]; !ok {
		c.Hosts[alias] = cfg
	}
}
135443
func (r *Repo) Status() (GitRepoStatus, error) {
	r.mu.RLock()
	defer r.mu.RUnlock()
	return r.status, r.err
}
5607
func (s *GetHealthCheckOutput) SetHealthCheck(v *HealthCheck) *GetHealthCheckOutput {
	s.HealthCheck = v
	return s
}
107703
func (s *DescribeEnvironmentHealthOutput) SetHealthStatus(v string) *DescribeEnvironmentHealthOutput {
	s.HealthStatus = &v
	return s
}
200978
func (s *Container) SetHealthStatus(v string) *Container {
	s.HealthStatus = &v
	return s
}
71684
func (s *ListHITsOutput) SetHITs(v []*HIT) *ListHITsOutput {
	s.HITs = v
	return s
}
1155310
func (s *SamplingRuleUpdate) SetHost(v string) *SamplingRuleUpdate {
	s.Host = &v
	return s
}
1025644
func (client *Client) SetLoadBalancerStatus(loadBalancerId string, status Status) (err error) {
	args := &SetLoadBalancerStatusArgs{
		LoadBalancerId:     loadBalancerId,
		LoadBalancerStatus: status,
	}
	response := &SetLoadBalancerStatusResponse{}
	err = client.Invoke("SetLoadBalancerStatus", args, response)
	return err
}
1224602
func (s *Session) SetHandshakeData(data *HandshakeData) {
	s.Lock()
	defer s.Unlock()

	s.handshakeData = data
}
744689
func (s *HIT) SetHITStatus(v string) *HIT {
	s.HITStatus = &v
	return s
}
272434
func (s *GetConfigInput) SetHapgList(v []*string) *GetConfigInput {
	s.HapgList = v
	return s
}
334188
func (s *EndpointDescription) SetHealthState(v string) *EndpointDescription {
	s.HealthState = &v
	return s
}
352839
func (s *InstanceDetails) SetHealthStatus(v string) *InstanceDetails {
	s.HealthStatus = &v
	return s
}
152028
func (e ServerErrorThrottle) ToStatus() (s keybase1.Status) {
	s.Code = StatusCodeServerErrorThrottle
	s.Name = "ERROR_THROTTLE"
	s.Desc = e.Msg
	return
}
243801
func (a *allocHealthSetter) SetHealth(healthy, isDeploy bool, trackerTaskEvents map[string]*structs.TaskEvent) {
	// Updating alloc deployment state is tricky because it may be nil, but
	// if it's not then we need to maintain the values of Canary and
	// ModifyIndex as they're only mutated by the server.
	a.ar.stateLock.Lock()
	a.ar.state.SetDeploymentStatus(time.Now(), healthy)
	a.ar.persistDeploymentStatus(a.ar.state.DeploymentStatus)
	terminalDesiredState := a.ar.alloc.ServerTerminalStatus()
	a.ar.stateLock.Unlock()

	// If deployment is unhealthy emit task events explaining why
	if !healthy && isDeploy && !terminalDesiredState {
		for task, event := range trackerTaskEvents {
			if tr, ok := a.ar.tasks[task]; ok {
				// Append but don't emit event since the server
				// will be updated below
				tr.AppendEvent(event)
			}
		}
	}

	// Gather the state of the other tasks
	states := make(map[string]*structs.TaskState, len(a.ar.tasks))
	for name, tr := range a.ar.tasks {
		states[name] = tr.TaskState()
	}

	// Build the client allocation
	calloc := a.ar.clientAlloc(states)

	// Update the server
	a.ar.stateUpdater.AllocStateUpdated(calloc)

	// Broadcast client alloc to listeners
	a.ar.allocBroadcaster.Send(calloc)
}
375845
func (s *Http) SetHttpStatus(v int64) *Http {
	s.HttpStatus = &v
	return s
}