本文整理汇总了Golang中github.com/buildkite/agent/logger.Warn函数的典型用法代码示例。如果您正苦于以下问题:Golang Warn函数的具体用法?Golang Warn怎么用?Golang Warn使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了Warn函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: finishJob
// Finishes the job in the Buildkite Agent API. This call will keep on retrying
// forever until it finally gets a successfull response from the API.
func (r *JobRunner) finishJob(finishedAt time.Time, exitStatus string, failedChunkCount int) error {
r.Job.FinishedAt = finishedAt.UTC().Format(time.RFC3339Nano)
r.Job.ExitStatus = exitStatus
r.Job.ChunksFailedCount = failedChunkCount
return retry.Do(func(s *retry.Stats) error {
response, err := r.APIClient.Jobs.Finish(r.Job)
if err != nil {
// If the API returns with a 422, that means that we
// succesfully tried to finish the job, but Buildkite
// rejected the finish for some reason. This can
// sometimes mean that Buildkite has cancelled the job
// before we get a chance to send the final API call
// (maybe this agent took too long to kill the
// process). In that case, we don't want to keep trying
// to finish the job forever so we'll just bail out and
// go find some more work to do.
if response != nil && response.StatusCode == 422 {
logger.Warn("Buildkite rejected the call to finish the job (%s)", err)
s.Break()
} else {
logger.Warn("%s (%s)", err, s)
}
}
return err
}, &retry.Config{Forever: true, Interval: 1 * time.Second})
}
示例2: CreateAgentTemplate
// Takes the options passed to the CLI, and creates an api.Agent record that
// will be sent to the Buildkite Agent API for registration.
func (r *AgentPool) CreateAgentTemplate() *api.Agent {
agent := &api.Agent{
Name: r.Name,
Priority: r.Priority,
MetaData: r.MetaData,
ScriptEvalEnabled: r.AgentConfiguration.CommandEval,
Version: Version(),
Build: BuildVersion(),
PID: os.Getpid(),
Arch: runtime.GOARCH,
}
// Attempt to add the EC2 meta-data
if r.MetaDataEC2 {
tags, err := EC2MetaData{}.Get()
if err != nil {
// Don't blow up if we can't find them, just show a nasty error.
logger.Error(fmt.Sprintf("Failed to fetch EC2 meta-data: %s", err.Error()))
} else {
for tag, value := range tags {
agent.MetaData = append(agent.MetaData, fmt.Sprintf("%s=%s", tag, value))
}
}
}
// Attempt to add the EC2 tags
if r.MetaDataEC2Tags {
tags, err := EC2Tags{}.Get()
if err != nil {
// Don't blow up if we can't find them, just show a nasty error.
logger.Error(fmt.Sprintf("Failed to find EC2 Tags: %s", err.Error()))
} else {
for tag, value := range tags {
agent.MetaData = append(agent.MetaData, fmt.Sprintf("%s=%s", tag, value))
}
}
}
var err error
// Add the hostname
agent.Hostname, err = os.Hostname()
if err != nil {
logger.Warn("Failed to find hostname: %s", err)
}
// Add the OS dump
agent.OS, err = system.VersionDump()
if err != nil {
logger.Warn("Failed to find OS information: %s", err)
}
return agent
}
示例3: Disconnect
// Disconnects the agent from the Buildkite Agent API, doesn't bother retrying
// because we want to disconnect as fast as possible.
func (a *AgentWorker) Disconnect() error {
_, err := a.APIClient.Agents.Disconnect()
if err != nil {
logger.Warn("There was an error sending the disconnect API call to Buildkite. If this agent still appears online, you may have to manually stop it (%s)", err)
}
return err
}
示例4: startJob
// Starts the job in the Buildkite Agent API. We'll retry on connection-related
// issues, but if a connection succeeds and we get an error response back from
// Buildkite, we won't bother retrying. For example, a "no such host" will
// retry, but a 422 from Buildkite won't.
func (r *JobRunner) startJob(startedAt time.Time) error {
r.Job.StartedAt = startedAt.UTC().Format(time.RFC3339Nano)
return retry.Do(func(s *retry.Stats) error {
_, err := r.APIClient.Jobs.Start(r.Job)
if err != nil {
if api.IsRetryableError(err) {
logger.Warn("%s (%s)", err, s)
} else {
logger.Warn("Buildkite rejected the call to start the job (%s)", err)
s.Break()
}
}
return err
}, &retry.Config{Maximum: 30, Interval: 5 * time.Second})
}
示例5: Start
func (d Download) Start() error {
return retry.Do(func(s *retry.Stats) error {
err := d.try()
if err != nil {
logger.Warn("Error trying to download %s (%s) %s", d.URL, err, s)
}
return err
}, &retry.Config{Maximum: d.Retries, Interval: 1 * time.Second})
}
示例6: Run
// Runs the job
func (r *JobRunner) Run() error {
logger.Info("Starting job %s", r.Job.ID)
// Start the build in the Buildkite Agent API. This is the first thing
// we do so if it fails, we don't have to worry about cleaning things
// up like started log streamer workers, etc.
if err := r.startJob(time.Now()); err != nil {
return err
}
// Start the header time streamer
if err := r.headerTimesStreamer.Start(); err != nil {
return err
}
// Start the log streamer
if err := r.logStreamer.Start(); err != nil {
return err
}
// Start the process. This will block until it finishes.
if err := r.process.Start(); err != nil {
// Send the error as output
r.logStreamer.Process(fmt.Sprintf("%s", err))
} else {
// Add the final output to the streamer
r.logStreamer.Process(r.process.Output())
}
// Store the finished at time
finishedAt := time.Now()
// Stop the header time streamer. This will block until all the chunks
// have been uploaded
r.headerTimesStreamer.Stop()
// Stop the log streamer. This will block until all the chunks have
// been uploaded
r.logStreamer.Stop()
// Warn about failed chunks
if r.logStreamer.ChunksFailedCount > 0 {
logger.Warn("%d chunks failed to upload for this job", r.logStreamer.ChunksFailedCount)
}
// Finish the build in the Buildkite Agent API
r.finishJob(finishedAt, r.process.ExitStatus, int(r.logStreamer.ChunksFailedCount))
// Wait for the routines that we spun up to finish
logger.Debug("[JobRunner] Waiting for all other routines to finish")
r.routineWaitGroup.Wait()
logger.Info("Finished job %s", r.Job.ID)
return nil
}
示例7: Create
func (a *ArtifactBatchCreator) Create() ([]*api.Artifact, error) {
length := len(a.Artifacts)
chunks := 30
// Split into the artifacts into chunks so we're not uploading a ton of
// files at once.
for i := 0; i < length; i += chunks {
j := i + chunks
if length < j {
j = length
}
// The artifacts that will be uploaded in this chunk
theseArtiacts := a.Artifacts[i:j]
// An ID is required so Buildkite can ensure this create
// operation is idompotent (if we try and upload the same ID
// twice, it'll just return the previous data and skip the
// upload)
batch := &api.ArtifactBatch{api.NewUUID(), theseArtiacts, a.UploadDestination}
logger.Info("Creating (%d-%d)/%d artifacts", i, j, length)
var creation *api.ArtifactBatchCreateResponse
var resp *api.Response
var err error
// Retry the batch upload a couple of times
err = retry.Do(func(s *retry.Stats) error {
creation, resp, err = a.APIClient.Artifacts.Create(a.JobID, batch)
if resp != nil && (resp.StatusCode == 401 || resp.StatusCode == 404 || resp.StatusCode == 500) {
s.Break()
}
if err != nil {
logger.Warn("%s (%s)", err, s)
}
return err
}, &retry.Config{Maximum: 10, Interval: 1 * time.Second})
// Did the batch creation eventually fail?
if err != nil {
return nil, err
}
// Save the id and instructions to each artifact
index := 0
for _, id := range creation.ArtifactIDs {
theseArtiacts[index].ID = id
theseArtiacts[index].UploadInstructions = creation.UploadInstructions
index += 1
}
}
return a.Artifacts, nil
}
示例8: Connect
// Connects the agent to the Buildkite Agent API, retrying up to 30 times if it
// fails.
func (a *AgentWorker) Connect() error {
return retry.Do(func(s *retry.Stats) error {
_, err := a.APIClient.Agents.Connect()
if err != nil {
logger.Warn("%s (%s)", err, s)
}
return err
}, &retry.Config{Maximum: 10, Interval: 1 * time.Second})
}
示例9: onUploadHeaderTime
func (r *JobRunner) onUploadHeaderTime(cursor int, total int, times map[string]string) {
retry.Do(func(s *retry.Stats) error {
_, err := r.APIClient.HeaderTimes.Save(r.Job.ID, &api.HeaderTimes{Times: times})
if err != nil {
logger.Warn("%s (%s)", err, s)
}
return err
}, &retry.Config{Maximum: 10, Interval: 5 * time.Second})
}
示例10: onUploadChunk
// Call when a chunk is ready for upload. It retry the chunk upload with an
// interval before giving up.
func (r *JobRunner) onUploadChunk(chunk *LogStreamerChunk) error {
return retry.Do(func(s *retry.Stats) error {
_, err := r.APIClient.Chunks.Upload(r.Job.ID, &api.Chunk{
Data: chunk.Data,
Sequence: chunk.Order,
})
if err != nil {
logger.Warn("%s (%s)", err, s)
}
return err
}, &retry.Config{Maximum: 10, Interval: 1 * time.Second})
}
示例11: Connect
// Connects the agent to the Buildkite Agent API, retrying up to 30 times if it
// fails.
func (a *AgentWorker) Connect() error {
// Update the proc title
a.UpdateProcTitle("connecting")
return retry.Do(func(s *retry.Stats) error {
_, err := a.APIClient.Agents.Connect()
if err != nil {
logger.Warn("%s (%s)", err, s)
}
return err
}, &retry.Config{Maximum: 10, Interval: 1 * time.Second})
}
示例12: RegisterAgent
// Takes the agent template and returns a registered agent. The registered
// agent includes the Access Token used to communicate with the Buildkite Agent
// API
func (r *AgentPool) RegisterAgent(agent *api.Agent) (*api.Agent, error) {
var registered *api.Agent
var err error
var resp *api.Response
register := func(s *retry.Stats) error {
registered, resp, err = r.APIClient.Agents.Register(agent)
if err != nil {
if resp != nil && resp.StatusCode == 401 {
logger.Warn("Buildkite rejected the registration (%s)", err)
s.Break()
} else {
logger.Warn("%s (%s)", err, s)
}
}
return err
}
err = retry.Do(register, &retry.Config{Maximum: 30, Interval: 1 * time.Second})
return registered, err
}
示例13: Stop
// Stops the agent from accepting new work and cancels any current work it's
// running
func (a *AgentWorker) Stop(graceful bool) {
// Only allow one stop to run at a time (because we're playing with
// channels)
a.stopMutex.Lock()
defer a.stopMutex.Unlock()
if graceful {
if a.stopping {
logger.Warn("Agent is already gracefully stopping...")
} else {
// If we have a job, tell the user that we'll wait for
// it to finish before disconnecting
if a.jobRunner != nil {
logger.Info("Gracefully stopping agent. Waiting for current job to finish before disconnecting...")
} else {
logger.Info("Gracefully stopping agent. Since there is no job running, the agent will disconnect immediately")
}
}
} else {
// If there's a job running, kill it, then disconnect
if a.jobRunner != nil {
logger.Info("Forefully stopping agent. The current job will be canceled before disconnecting...")
// Kill the current job. Doesn't do anything if the job
// is already being killed, so it's safe to call
// multiple times.
a.jobRunner.Kill()
} else {
logger.Info("Forefully stopping agent. Since there is no job running, the agent will disconnect immediately")
}
}
// We don't need to do the below operations again since we've already
// done them before
if a.stopping {
return
}
// Update the proc title
a.UpdateProcTitle("stopping")
// If we have a ticker, stop it, and send a signal to the stop channel,
// which will cause the agent worker to stop looping immediatly.
if a.ticker != nil {
close(a.stop)
}
// Mark the agent as stopping
a.stopping = true
}
示例14: onProcessStartCallback
func (r *JobRunner) onProcessStartCallback() {
// Start a routine that will grab the output every few seconds and send
// it back to Buildkite
go func() {
// Add to the wait group
r.wg.Add(1)
for r.process.Running {
// Send the output of the process to the log streamer
// for processing
r.logStreamer.Process(r.process.Output())
// Check the output in another second
time.Sleep(1 * time.Second)
}
// Mark this routine as done in the wait group
r.wg.Done()
logger.Debug("Routine that processes the log has finished")
}()
// Start a routine that will grab the output every few seconds and send it back to Buildkite
go func() {
// Add to the wait group
r.wg.Add(1)
for r.process.Running {
// Re-get the job and check it's status to see if it's been
// cancelled
jobState, _, err := r.APIClient.Jobs.GetState(r.Job.ID)
if err != nil {
// We don't really care if it fails, we'll just
// try again in a second anyway
logger.Warn("Problem with getting job state %s (%s)", r.Job.ID, err)
} else if jobState.State == "canceling" || jobState.State == "canceled" {
r.Kill()
}
// Check for cancellations every few seconds
time.Sleep(3 * time.Second)
}
// Mark this routine as done in the wait group
r.wg.Done()
logger.Debug("Routine that refreshes the job has finished")
}()
}
示例15: Heartbeat
// Performs a heatbeat
func (a *AgentWorker) Heartbeat() error {
var beat *api.Heartbeat
var err error
// Retry the heartbeat a few times
err = retry.Do(func(s *retry.Stats) error {
beat, _, err = a.APIClient.Heartbeats.Beat()
if err != nil {
logger.Warn("%s (%s)", err, s)
}
return err
}, &retry.Config{Maximum: 5, Interval: 1 * time.Second})
if err != nil {
return err
}
logger.Debug("Heartbeat sent at %s and received at %s", beat.SentAt, beat.ReceivedAt)
return nil
}