/
MailTemplateHelpers.java
170 lines (134 loc) · 6.63 KB
/
MailTemplateHelpers.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
package com.hubspot.singularity.smtp;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.TimeZone;
import org.apache.commons.lang3.text.WordUtils;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.common.base.Optional;
import com.google.common.collect.Lists;
import com.google.inject.Inject;
import com.google.inject.Singleton;
import com.hubspot.mesos.MesosUtils;
import com.hubspot.mesos.json.MesosFileChunkObject;
import com.hubspot.singularity.ExtendedTaskState;
import com.hubspot.singularity.SingularityEmailType;
import com.hubspot.singularity.SingularityTask;
import com.hubspot.singularity.SingularityTaskHistoryUpdate;
import com.hubspot.singularity.SingularityTaskId;
import com.hubspot.singularity.config.SMTPConfiguration;
import com.hubspot.singularity.config.SingularityConfiguration;
import com.hubspot.singularity.data.SandboxManager;
@Singleton
public class MailTemplateHelpers {
private static final Logger LOG = LoggerFactory.getLogger(MailTemplateHelpers.class);
private static final String TASK_LINK_FORMAT = "%s/task/%s";
private static final String REQUEST_LINK_FORMAT = "%s/request/%s";
private static final String LOG_LINK_FORMAT = "%s/task/%s/tail/%s";
private final SandboxManager sandboxManager;
private final Optional<String> uiBaseUrl;
private final Optional<SMTPConfiguration> smtpConfiguration;
private final String taskDatePattern;
private final TimeZone timeZone;
@Inject
public MailTemplateHelpers(SandboxManager sandboxManager, SingularityConfiguration singularityConfiguration) {
this.taskDatePattern = singularityConfiguration.getMailerDatePattern();
this.timeZone = singularityConfiguration.getMailerTimeZone();
this.uiBaseUrl = singularityConfiguration.getUiConfiguration().getBaseUrl();
this.sandboxManager = sandboxManager;
this.smtpConfiguration = singularityConfiguration.getSmtpConfiguration();
}
public List<SingularityMailTaskHistoryUpdate> getJadeTaskHistory(Collection<SingularityTaskHistoryUpdate> taskHistory) {
List<SingularityMailTaskHistoryUpdate> output = Lists.newArrayListWithCapacity(taskHistory.size());
for (SingularityTaskHistoryUpdate taskUpdate : taskHistory) {
output.add(
new SingularityMailTaskHistoryUpdate(
DateFormatUtils.format(taskUpdate.getTimestamp(), taskDatePattern, timeZone),
WordUtils.capitalize(taskUpdate.getTaskState().getDisplayName()),
taskUpdate.getStatusMessage().or("")));
}
return output;
}
public List<SingularityMailTaskLog> getTaskLogs(SingularityTaskId taskId, Optional<SingularityTask> task, Optional<String> directory) {
if (!smtpConfiguration.isPresent()) {
LOG.warn("Tried to getTaskLogs for sending email without SMTP configuration set.");
return Collections.emptyList();
}
List<String> taskEmailTailFiles = smtpConfiguration.get().getTaskEmailTailFiles();
List<SingularityMailTaskLog> logTails = Lists.newArrayListWithCapacity(taskEmailTailFiles.size());
for (String filePath : taskEmailTailFiles) {
// To enable support for tailing the service.log file, replace instances of $MESOS_TASK_ID.
filePath = filePath.replaceAll("\\$MESOS_TASK_ID", MesosUtils.getSafeTaskIdForDirectory(taskId.getId()));
logTails.add(
new SingularityMailTaskLog(
filePath,
getFileName(filePath),
getSingularityLogLink(filePath, taskId.getId()),
getTaskLogFile(taskId, filePath, task, directory).or("")));
}
return logTails;
}
private Optional<String> getTaskLogFile(final SingularityTaskId taskId, final String filename, final Optional<SingularityTask> task, final Optional<String> directory) {
if (!smtpConfiguration.isPresent()) {
LOG.warn("Tried to get a task log file without SMTP configuration set up.");
return Optional.absent();
}
if (!task.isPresent() || !directory.isPresent()) {
LOG.warn("Couldn't retrieve {} for {} because task ({}) or directory ({}) wasn't present", filename, taskId, task.isPresent(), directory.isPresent());
return Optional.absent();
}
final String slaveHostname = task.get().getOffer().getHostname();
final String fullPath = String.format("%s/%s", directory.get(), filename);
final Long logLength = (long) smtpConfiguration.get().getTaskLogLength();
final Optional<MesosFileChunkObject> logChunkObject;
try {
logChunkObject = sandboxManager.read(slaveHostname, fullPath, Optional.of(0L), Optional.of(logLength));
} catch (RuntimeException e) {
LOG.error("Sandboxmanager failed to read {}/{} on slave {}", directory.get(), filename, slaveHostname, e);
return Optional.absent();
}
if (logChunkObject.isPresent()) {
return Optional.of(logChunkObject.get().getData());
} else {
LOG.error("Failed to get {} log for {}", filename, taskId.getId());
return Optional.absent();
}
}
public String getFileName(String path) {
String[] splitPath = path.split("/");
return splitPath[splitPath.length - 1];
}
public String getSingularityTaskLink(String taskId) {
if (!uiBaseUrl.isPresent()) {
return "";
}
return String.format(TASK_LINK_FORMAT, uiBaseUrl.get(), taskId);
}
public String getSingularityRequestLink(String requestId) {
if (!uiBaseUrl.isPresent()) {
return "";
}
return String.format(REQUEST_LINK_FORMAT, uiBaseUrl.get(), requestId);
}
public String getSingularityLogLink(String logPath, String taskId) {
if (!uiBaseUrl.isPresent()) {
return "";
}
return String.format(LOG_LINK_FORMAT, uiBaseUrl.get(), taskId, logPath);
}
public String getSubjectForTaskHistory(SingularityTaskId taskId, ExtendedTaskState state, SingularityEmailType type, Collection<SingularityTaskHistoryUpdate> history) {
if (type == SingularityEmailType.TASK_SCHEDULED_OVERDUE_TO_FINISH) {
return String.format("Task is overdue to finish (%s)", taskId.toString());
}
if (!didTaskRun(history)) {
return String.format("Task never started and was %s (%s)", state.getDisplayName(), taskId.toString());
}
return String.format("Task %s (%s)", state.getDisplayName(), taskId.toString());
}
public boolean didTaskRun(Collection<SingularityTaskHistoryUpdate> history) {
SingularityTaskHistoryUpdate.SimplifiedTaskState simplifiedTaskState = SingularityTaskHistoryUpdate.getCurrentState(history);
return simplifiedTaskState == SingularityTaskHistoryUpdate.SimplifiedTaskState.DONE || simplifiedTaskState == SingularityTaskHistoryUpdate.SimplifiedTaskState.RUNNING;
}
}