fork download
copy 
  1. import java.io.IOException;
  2. import java.io.PrintWriter;
  3. import java.io.Serializable;
  4. import java.io.StringWriter;
  5. import java.text.DateFormat;
  6. import java.text.SimpleDateFormat;
  7. import java.util.ArrayList;
  8. import java.util.Calendar;
  9. import java.util.GregorianCalendar;
  10. import java.util.List;
  11. import java.util.Map;
  12. import java.util.Timer;
  13. import java.util.TimerTask;
  14.  
  15. import javax.sql.DataSource;
  16.  
  17. import org.slf4j.Logger;
  18. import org.slf4j.LoggerFactory;
  19. import org.springframework.jdbc.core.JdbcTemplate;
  20. import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
  21. import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
  22. import org.springframework.jdbc.support.GeneratedKeyHolder;
  23. import org.springframework.jdbc.support.KeyHolder;
  24.  
  25. /**
  26.  * Object responsible for creating EmailJobs and EmailJobWorkers. Also responsible for starting EmailJobWorkers once their start time has been reached.
  27.  * Also responsible for removing files and tables associated with email jobs upon a request from a user to remove them.
  28.  * 
  29.  * 
  30.  * @version 1.0.0
  31.  */
  32. public class EmailJobManager implements Serializable
  33. {
  34. 	private static final long serialVersionUID = 1L;
  35.  
  36. 	private static Logger logger = LoggerFactory.getLogger(EmailJobManager.class.getName());
  37.  
  38. 	/**Location on server of HTML files used for emails*/
  39. 	public static final String HTML_FILE_DIR = "C:\\test\\";
  40.  
  41. 	/**Delay in minutes before the manager checks to see if any jobs need to start*/
  42. 	private final int JOB_CHECK_DELAY = 1;
  43.  
  44. 	/*Spring JDBC objects*/
  45. 	private DataSource ds;
  46. 	private transient JdbcTemplate jt;
  47. 	private transient NamedParameterJdbcTemplate njt;
  48.  
  49. 	/**List of all workers still currently actively sending out emails*/
  50. 	private List<EmailJobWorker> activeWorkers = new ArrayList<EmailJobWorker>();
  51. 	/**List of workers that completed their jobs*/
  52. 	private List<EmailJobWorker> finishedWorkers = new ArrayList<EmailJobWorker>();
  53. 	/**List of paused workers*/
  54. 	private List<EmailJobWorker> pausedWorkers = new ArrayList<EmailJobWorker>();
  55.  
  56. 	/**Timer that fires telling manager to check to see if jobs need to be started, or moved to finished list*/
  57. 	private transient Timer jobCheckTimer = new Timer("EmailJobManager");
  58.  
  59. 	public EmailJobManager(DataSource ds)
  60. 	{
  61. 		this.njt = new NamedParameterJdbcTemplate(ds);
  62. 		this.ds = ds;
  63. 		this.jt = new JdbcTemplate(ds);
  64.  
  65. 		loadJobs();
  66.  
  67. 		jobCheckTimer.schedule(new TimerTask(){
  68.  
  69. 			@Override
  70. 			public void run()
  71. 			{
  72. 				logger.info("EmailJobManager timer run started.");
  73.  
  74.  
  75. 				for(EmailJobWorker worker: activeWorkers)
  76. 				{
  77. 					logger.info("EmailJobWorker " + worker.getEmailJobName() + " is an active worker.");
  78. 					logger.info("Memory Address in manager timer loop 1 for " + worker.getEmailJobName() + " ({})", worker.toString());
  79. 				}
  80.  
  81. 				Calendar c = new GregorianCalendar();
  82.  
  83. 				logger.info("Size of pausedWorkers: {}", pausedWorkers.size());
  84.  
  85. 				for(EmailJobWorker worker : pausedWorkers)
  86. 				{
  87. 					logger.info("Memory Address in manager timer loop 2 for " + worker.getEmailJobName() + " ({})", worker.toString());
  88.  
  89. 					SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yy - HH:mm");
  90.  
  91. 					logger.info("Comparing current time ({}) to EmailJobWorker " + worker.getEmailJobName() + " start time ({})", sdf.format(c.getTime()), sdf.format(worker.getStartDate()));
  92.  
  93. 					if(c.compareTo(worker.getEmailJob().getStartTime()) > 0)
  94. 					{
  95. 						pausedWorkers.remove(worker);
  96. 						activeWorkers.add(worker);
  97. 						worker.start();
  98. 						logger.info("EmailJob " + worker.getEmailJob().getJobName() + " started.\n");
  99. 					}
  100. 				}
  101.  
  102. 				for(EmailJobWorker worker : activeWorkers)
  103. 				{
  104. 					if(worker.isCompleted())
  105. 					{
  106. 						activeWorkers.remove(worker);
  107. 						finishedWorkers.add(worker);
  108. 						logger.info("Worker " + worker.getEmailJobName() + " has completed.");
  109. 					}
  110. 				}
  111. 			}
  112.  
  113. 		}, 0, /*interval in milliseconds*/JOB_CHECK_DELAY * 60 * 1000);
  114.  
  115. 		logger.info("EmailJobManager timer started sucesfully. (sleepTime) ({})", JOB_CHECK_DELAY);
  116. 	}
  117.  
  118. 	/**
  119. 	 * Adds new email job to this manager's duties.
  120. 	 * 
  121. 	 * @param jobName Name of the email job
  122. 	 * @param startTime Time for the email job to start
  123. 	 * @param batchSize Number of emails to be sent out per time interval
  124. 	 * @param timeInterval Time between batches in minutes
  125. 	 * @param emailSubject Subject of the email
  126. 	 * @param fromAddress The email address the emails will be sent from
  127. 	 * @param password Password of the email address
  128. 	 * @throws IOException If HTML file to be used for the email is not found
  129. 	 */
  130. 	public void addJob(String jobName, Calendar startTime, int batchSize, int timeInterval, String emailSubject, String fromAddress, String password) throws IOException
  131. 	{
  132. 		String SQL = "INSERT INTO email_jobs (jobName, emailSubject, email, password, startTime, batchSize, timeInterval) VALUES(:jobName, :emailSubject, :email, :password, :startTime, :batchSize, :timeInterval)";
  133. 		MapSqlParameterSource params = new MapSqlParameterSource();
  134. 		params.addValue("jobName", jobName);
  135. 		params.addValue("emailSubject", emailSubject);
  136. 		params.addValue("email", fromAddress);
  137. 		params.addValue("password", password);
  138. 		DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
  139. 		params.addValue("startTime", dateFormat.format(startTime.getTime()));
  140. 		params.addValue("batchSize", batchSize);
  141. 		params.addValue("timeInterval", timeInterval);
  142. 		KeyHolder keyHolder = new GeneratedKeyHolder();
  143. 		njt.update(SQL, params, keyHolder);
  144. 		int jobId = keyHolder.getKey().intValue();
  145.  
  146. 		EmailJob job = new EmailJob(jobId, jobName, startTime, HTML_FILE_DIR + "/" + jobName + ".html");
  147.  
  148. 		EmailJobWorker newWorker = new EmailJobWorker(job, batchSize, timeInterval, ds, emailSubject, fromAddress, password);
  149.  
  150. 		logger.info("Memory Address in addJob for " + newWorker.getEmailJobName() + " ({})", newWorker.toString());
  151.  
  152. 		activeWorkers.add(newWorker);
  153. 	}
  154.  
  155. 	/**
  156. 	 * Pauses a job that is currently running.
  157. 	 * 
  158. 	 * @param jobName Name of the job to pause.
  159. 	 */
  160. 	public void pauseJob(String jobName)
  161. 	{
  162. 		for(EmailJobWorker worker : activeWorkers)
  163. 		{
  164. 			if(worker.getEmailJob().getJobName().equals(jobName))
  165. 			{
  166. 				activeWorkers.remove(worker);
  167. 				pausedWorkers.add(worker);
  168. 				worker.stop();
  169. 				return;
  170. 			}
  171. 		}
  172. 	}
  173.  
  174. 	public void startJob(String jobName)
  175. 	{
  176. 		for(EmailJobWorker worker : pausedWorkers)
  177. 		{
  178. 			if(worker.getEmailJobName().equals(jobName))
  179. 			{
  180. 				pausedWorkers.remove(worker);
  181. 				activeWorkers.add(worker);
  182. 				worker.start();
  183. 				return;
  184. 			}
  185. 		}
  186.  
  187. 		for(EmailJobWorker worker : finishedWorkers)
  188. 		{
  189. 			if(worker.getEmailJobName().equals(jobName))
  190. 			{
  191. 				finishedWorkers.remove(worker);
  192. 				activeWorkers.add(worker);
  193. 				worker.restart();
  194. 				return;
  195. 			}
  196. 		}
  197. 	}
  198.  
  199. 	public void destroyJob(String jobName)
  200. 	{
  201. 		for(EmailJobWorker worker : getActiveWorkers())
  202. 		{
  203. 			if(worker.getEmailJobName().equals(jobName))
  204. 			{
  205. 				worker.stop();
  206. 				activeWorkers.remove(worker);
  207. 			}
  208. 		}
  209.  
  210. 		for(EmailJobWorker worker : getPausedWorkers())
  211. 		{
  212. 			if(worker.getEmailJobName().equals(jobName))
  213. 			{
  214. 				worker.stop();
  215. 				pausedWorkers.remove(worker);
  216. 			}
  217. 		}
  218.  
  219. 		for(EmailJobWorker worker : getFinishedWorkers())
  220. 		{
  221. 			if(worker.getEmailJobName().equals(jobName))
  222. 			{
  223. 				finishedWorkers.remove(worker);
  224. 			}
  225. 		}
  226. 	}
  227.  
  228. 	public List<EmailJobWorker> getActiveWorkers()
  229. 	{
  230. 		return this.activeWorkers;
  231. 	}
  232.  
  233. 	public List<EmailJobWorker> getPausedWorkers()
  234. 	{
  235. 		return this.pausedWorkers;
  236. 	}
  237.  
  238. 	public List<EmailJobWorker> getFinishedWorkers()
  239. 	{
  240. 		return this.finishedWorkers;
  241. 	}
  242.  
  243. 	/**
  244. 	 * Checks to see if any jobs were not completed as expected due to hardware error. Recreates the EmailJob and EmailJobWorker responsible.
  245. 	 */
  246. 	private void loadJobs()
  247. 	{
  248. 		String SQL = "SELECT * FROM email_jobs";
  249.  
  250. 		List<Map<String, Object>> rows = jt.queryForList(SQL);
  251.  
  252. 		for(Map<String, Object> row : rows)
  253. 		{
  254. 			int jobId = (Integer)row.get("id");
  255. 			String jobName = (String)row.get("jobName");
  256. 			String emailSubject = (String)row.get("emailSubject");
  257. 			String email = (String)row.get("email");
  258. 			String password = (String)row.get("password");
  259. 			Calendar startTime = new GregorianCalendar();
  260. 			startTime.setTime((java.util.Date)row.get("startTime"));
  261. 			int batchSize = (Integer)row.get("batchSize");
  262. 			int timeInterval = (Integer)row.get("timeInterval");
  263. 			boolean completed = (Boolean)row.get("completed");
  264. 			boolean paused = (Boolean)row.get("paused");
  265.  
  266. 			//Get id of next email to be sent out
  267. 			SQL = "SELECT MIN(id) FROM " + jobName + "_email_list" + " WHERE sentOut = false";
  268. 			int startId = njt.queryForInt(SQL, new MapSqlParameterSource());
  269.  
  270. 			EmailJob job;
  271. 			try 
  272. 			{
  273. 				job = new EmailJob(jobId, jobName, startTime, HTML_FILE_DIR + "/" + jobName + ".html");
  274. 			} 
  275. 			catch (IOException e) 
  276. 			{
  277. 				StringWriter sw = new StringWriter();
  278. 				e.printStackTrace(new PrintWriter(sw));
  279. 				String stackTrace = sw.toString();
  280.  
  281. 				logger.error("EmailJob " + jobName + " failed to load. HTML file at " + HTML_FILE_DIR + "/" + jobName + ".html" + " was not found.\n" + stackTrace + "\n");
  282.  
  283. 				continue;
  284. 			}
  285.  
  286. 			EmailJobWorker worker = new EmailJobWorker(job, batchSize, timeInterval, ds, emailSubject, email, password, startId);			
  287.  
  288. 			if(completed)
  289. 			{
  290. 				finishedWorkers.add(worker);
  291. 				logger.info("EmailJobWorker " + jobName + " has been added to the finished worker pool.");
  292. 			}
  293. 			else
  294. 			{
  295. 				logger.info("Worker " + worker.getEmailJobName() + " has been added to pausedWorkers list with memory address ({})", worker.toString());
  296. 				pausedWorkers.add(worker);
  297. 			}
  298.  
  299. 			logger.info("EmailJob " + jobName + " loaded sucessfully.");
  300. 		}
  301. 	}
  302. }
  303.  
Not running #stdin #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Standard output is empty
https://ideone.com/hR7et
language:
Java (HotSpot 12)
created:
13 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!