public synchronized void messageReceived(int to, Message m) {
DrainMsg mhMsg = (DrainMsg) m;
log.debug(
"incoming: localDest: "
+ to
+ " type:"
+ mhMsg.get_type()
+ " hops:"
+ (16 - mhMsg.get_ttl())
+ " seqNo:"
+ mhMsg.get_seqNo()
+ " source:"
+ mhMsg.get_source()
+ " finalDest:"
+ mhMsg.get_dest());
// lets assume that the network cannot buffer more than 25 drain msgs from a single source at a
// time (should be more than reasonable)
if (seqNos.containsKey(new Integer(mhMsg.get_source()))) {
int oldSeqNo = ((Integer) seqNos.get(new Integer(mhMsg.get_source()))).intValue();
int upperBound = mhMsg.get_seqNo() + 25;
int wrappedUpperBound = 25 - (255 - mhMsg.get_seqNo());
if ((oldSeqNo >= mhMsg.get_seqNo() && oldSeqNo < upperBound)
|| (oldSeqNo >= 0 && oldSeqNo < wrappedUpperBound)) {
log.debug(
"Dropping message from "
+ mhMsg.get_source()
+ " with duplicate seqNo: "
+ mhMsg.get_seqNo());
return;
}
}
seqNos.put(new Integer(mhMsg.get_source()), new Integer(mhMsg.get_seqNo()));
if (to != spAddr && to != MoteIF.TOS_BCAST_ADDR && to != TOS_UART_ADDR) {
log.debug("Dropping message not for me.");
return;
}
HashSet promiscuousSet = (HashSet) idTable.get(new Integer(BCAST_ID));
HashSet listenerSet = (HashSet) idTable.get(new Integer(mhMsg.get_type()));
if (listenerSet != null && promiscuousSet != null) {
listenerSet.addAll(promiscuousSet);
} else if (listenerSet == null && promiscuousSet != null) {
listenerSet = promiscuousSet;
}
if (listenerSet == null) {
log.debug("No Listener for type: " + mhMsg.get_type());
return;
}
for (Iterator it = listenerSet.iterator(); it.hasNext(); ) {
MessageListener ml = (MessageListener) it.next();
ml.messageReceived(to, mhMsg);
}
}
public void update(Observable source, Object object) {
if (source instanceof Users) {
if (!this.isDisabled()) {
try {
Operations.sendUserNamesList(users.getUserNames(), out);
} catch (IOException io) {
logger.error("IO Exception", io);
}
}
}
if (source instanceof Messages) {
try {
Operations.sendMessage((MessageType) object, out);
} catch (IOException io) {
if (out != null) {
try {
out.close();
} catch (Exception ioe) {
logger.error("Failed to close the output stream", ioe);
}
}
logger.error("Impossible to send messages", io);
}
}
}
public List<CIBuild> getBuilds(CIJob job) throws PhrescoException {
if (debugEnabled) {
S_LOGGER.debug("Entering Method CIManagerImpl.getCIBuilds(CIJob job)");
}
List<CIBuild> ciBuilds = null;
try {
if (debugEnabled) {
S_LOGGER.debug("getCIBuilds() JobName = " + job.getName());
}
JsonArray jsonArray = getBuildsArray(job);
ciBuilds = new ArrayList<CIBuild>(jsonArray.size());
Gson gson = new Gson();
CIBuild ciBuild = null;
for (int i = 0; i < jsonArray.size(); i++) {
ciBuild = gson.fromJson(jsonArray.get(i), CIBuild.class);
setBuildStatus(ciBuild, job);
String buildUrl = ciBuild.getUrl();
String jenkinUrl = job.getJenkinsUrl() + ":" + job.getJenkinsPort();
buildUrl =
buildUrl.replaceAll(
"localhost:" + job.getJenkinsPort(),
jenkinUrl); // when displaying url it should display setup machine ip
ciBuild.setUrl(buildUrl);
ciBuilds.add(ciBuild);
}
} catch (Exception e) {
if (debugEnabled) {
S_LOGGER.debug(
"Entering Method CIManagerImpl.getCIBuilds(CIJob job) " + e.getLocalizedMessage());
}
}
return ciBuilds;
}
private CLI getCLI(CIJob job) throws PhrescoException {
if (debugEnabled) {
S_LOGGER.debug("Entering Method CIManagerImpl.getCLI()");
}
String jenkinsUrl =
HTTP_PROTOCOL
+ PROTOCOL_POSTFIX
+ job.getJenkinsUrl()
+ COLON
+ job.getJenkinsPort()
+ FORWARD_SLASH
+ CI
+ FORWARD_SLASH;
if (debugEnabled) {
S_LOGGER.debug("jenkinsUrl to get cli object " + jenkinsUrl);
}
try {
return new CLI(new URL(jenkinsUrl));
} catch (MalformedURLException e) {
throw new PhrescoException(e);
} catch (IOException e) {
throw new PhrescoException(e);
} catch (InterruptedException e) {
throw new PhrescoException(e);
}
}
private CIJobStatus buildJob(CIJob job) throws PhrescoException {
if (debugEnabled) {
S_LOGGER.debug("Entering Method CIManagerImpl.buildJob(CIJob job)");
}
cli = getCLI(job);
List<String> argList = new ArrayList<String>();
argList.add(FrameworkConstants.CI_BUILD_JOB_COMMAND);
argList.add(job.getName());
try {
int status = cli.execute(argList);
String message = FrameworkConstants.CI_BUILD_STARTED;
if (status == FrameworkConstants.JOB_STATUS_NOTOK) {
message = FrameworkConstants.CI_BUILD_STARTING_ERROR;
}
return new CIJobStatus(status, message);
} finally {
if (cli != null) {
try {
cli.close();
} catch (IOException e) {
if (debugEnabled) {
S_LOGGER.error(e.getLocalizedMessage());
}
} catch (InterruptedException e) {
if (debugEnabled) {
S_LOGGER.error(e.getLocalizedMessage());
}
}
}
}
}
private void setSvnCredential(CIJob job) throws JDOMException, IOException {
S_LOGGER.debug("Entering Method CIManagerImpl.setSvnCredential");
try {
String jenkinsTemplateDir = Utility.getJenkinsTemplateDir();
String credentialFilePath = jenkinsTemplateDir + job.getRepoType() + HYPHEN + CREDENTIAL_XML;
if (debugEnabled) {
S_LOGGER.debug("credentialFilePath ... " + credentialFilePath);
}
File credentialFile = new File(credentialFilePath);
SvnProcessor processor = new SvnProcessor(credentialFile);
// DataInputStream in = new DataInputStream(new FileInputStream(credentialFile));
// while (in.available() != 0) {
// System.out.println(in.readLine());
// }
// in.close();
processor.changeNodeValue("credentials/entry//userName", job.getUserName());
processor.changeNodeValue("credentials/entry//password", job.getPassword());
processor.writeStream(new File(Utility.getJenkinsHome() + File.separator + job.getName()));
// jenkins home location
String jenkinsJobHome = System.getenv(JENKINS_HOME);
StringBuilder builder = new StringBuilder(jenkinsJobHome);
builder.append(File.separator);
processor.writeStream(new File(builder.toString() + CI_CREDENTIAL_XML));
} catch (Exception e) {
S_LOGGER.error(
"Entered into the catch block of CIManagerImpl.setSvnCredential "
+ e.getLocalizedMessage());
}
}
public void updateJob(ApplicationInfo appInfo, CIJob job) throws PhrescoException {
if (debugEnabled) {
S_LOGGER.debug(
"Entering Method ProjectAdministratorImpl.updateJob(Project project, CIJob job)");
}
FileWriter writer = null;
try {
CIJobStatus jobStatus = configureJob(job, FrameworkConstants.CI_UPDATE_JOB_COMMAND);
if (jobStatus.getCode() == -1) {
throw new PhrescoException(jobStatus.getMessage());
}
if (debugEnabled) {
S_LOGGER.debug("getCustomModules() ProjectInfo = " + appInfo);
}
updateJsonJob(appInfo, job);
} catch (ClientHandlerException ex) {
if (debugEnabled) {
S_LOGGER.error(ex.getLocalizedMessage());
}
throw new PhrescoException(ex);
} finally {
if (writer != null) {
try {
writer.close();
} catch (IOException e) {
if (debugEnabled) {
S_LOGGER.error(e.getLocalizedMessage());
}
}
}
}
}
/**
* getLocalizedMessage is used to localize the messages being used in exceptions with arguments
* inserted appropriately.
*/
public static String getLocalizedMessage(Logger logger, String key, Object[] args) {
try {
ResourceBundle rb = logger.getResourceBundle();
String message = rb.getString(key);
return MessageFormat.format(message, args);
} catch (Exception ex) {
logger.log(Level.FINE, "JTS:Error while localizing the log message");
return key;
}
}
// When already existing adapted project is created , need to move to new adapted project
private boolean deleteCIJobFile(ApplicationInfo appInfo) throws PhrescoException {
S_LOGGER.debug("Entering Method ProjectAdministratorImpl.deleteCI()");
try {
File ciJobInfo = new File(getCIJobPath(appInfo));
return ciJobInfo.delete();
} catch (ClientHandlerException ex) {
S_LOGGER.error(
"Entered into catch block of ProjectAdministratorImpl.deleteCI()"
+ ex.getLocalizedMessage());
throw new PhrescoException(ex);
}
}
/**
* Return the value associated with the first pattern that the string matches, or the specified
* default value if none, considering only patterns whose associated value is less than or equal
* to maxPri.
*/
public int getMatch(String str, int dfault, int maxPri) {
Perl5Matcher matcher = RegexpUtil.getMatcher();
for (Map.Entry<Pattern, Integer> ent : patternMap.entrySet()) {
if (ent.getValue() <= maxPri) {
Pattern pat = ent.getKey();
if (matcher.contains(str, pat)) {
log.debug2("getMatch(" + str + "): " + ent.getValue());
return ent.getValue();
}
}
}
log.debug2("getMatch(" + str + "): default: " + dfault);
return dfault;
}
private String getJsonResponse(String jsonUrl) throws PhrescoException {
if (debugEnabled) {
S_LOGGER.debug("Entering Method CIManagerImpl.getJsonResponse(String jsonUrl)");
S_LOGGER.debug("getJsonResponse() JSonUrl = " + jsonUrl);
}
try {
HttpClient httpClient = new DefaultHttpClient();
HttpGet httpget = new HttpGet(jsonUrl);
ResponseHandler<String> responseHandler = new BasicResponseHandler();
return httpClient.execute(httpget, responseHandler);
} catch (IOException e) {
throw new PhrescoException(e);
}
}
private void setBuildStatus(CIBuild ciBuild, CIJob job) throws PhrescoException {
S_LOGGER.debug("Entering Method CIManagerImpl.setBuildStatus(CIBuild ciBuild)");
S_LOGGER.debug("setBuildStatus() url = " + ciBuild.getUrl());
String buildUrl = ciBuild.getUrl();
String jenkinsUrl = job.getJenkinsUrl() + ":" + job.getJenkinsPort();
buildUrl =
buildUrl.replaceAll(
"localhost:" + job.getJenkinsPort(),
jenkinsUrl); // display the jenkins running url in ci list
String response = getJsonResponse(buildUrl + API_JSON);
JsonParser parser = new JsonParser();
JsonElement jsonElement = parser.parse(response);
JsonObject jsonObject = jsonElement.getAsJsonObject();
JsonElement resultJson = jsonObject.get(FrameworkConstants.CI_JOB_BUILD_RESULT);
JsonElement idJson = jsonObject.get(FrameworkConstants.CI_JOB_BUILD_ID);
JsonElement timeJson = jsonObject.get(FrameworkConstants.CI_JOB_BUILD_TIME_STAMP);
JsonArray asJsonArray = jsonObject.getAsJsonArray(FrameworkConstants.CI_JOB_BUILD_ARTIFACTS);
if (jsonObject
.get(FrameworkConstants.CI_JOB_BUILD_RESULT)
.toString()
.equals(STRING_NULL)) { // when build is result is not known
ciBuild.setStatus(INPROGRESS);
} else if (resultJson.getAsString().equals(CI_SUCCESS_FLAG)
&& asJsonArray.size()
< 1) { // when build is success and zip relative path is not added in json
ciBuild.setStatus(INPROGRESS);
} else {
ciBuild.setStatus(resultJson.getAsString());
// download path
for (JsonElement jsonArtElement : asJsonArray) {
String buildDownloadZip =
jsonArtElement
.getAsJsonObject()
.get(FrameworkConstants.CI_JOB_BUILD_DOWNLOAD_PATH)
.toString();
if (buildDownloadZip.endsWith(CI_ZIP)) {
if (debugEnabled) {
S_LOGGER.debug("download artifact " + buildDownloadZip);
}
ciBuild.setDownload(buildDownloadZip);
}
}
}
ciBuild.setId(idJson.getAsString());
String dispFormat = DD_MM_YYYY_HH_MM_SS;
ciBuild.setTimeStamp(getDate(timeJson.getAsString(), dispFormat));
}
private void setMailCredential(CIJob job) {
if (debugEnabled) {
S_LOGGER.debug("Entering Method CIManagerImpl.setMailCredential");
}
try {
String jenkinsTemplateDir = Utility.getJenkinsTemplateDir();
String mailFilePath = jenkinsTemplateDir + MAIL + HYPHEN + CREDENTIAL_XML;
if (debugEnabled) {
S_LOGGER.debug("configFilePath ... " + mailFilePath);
}
File mailFile = new File(mailFilePath);
SvnProcessor processor = new SvnProcessor(mailFile);
// DataInputStream in = new DataInputStream(new FileInputStream(mailFile));
// while (in.available() != 0) {
// System.out.println(in.readLine());
// }
// in.close();
// Mail have to go with jenkins running email address
InetAddress ownIP = InetAddress.getLocalHost();
processor.changeNodeValue(
CI_HUDSONURL,
HTTP_PROTOCOL
+ PROTOCOL_POSTFIX
+ ownIP.getHostAddress()
+ COLON
+ job.getJenkinsPort()
+ FORWARD_SLASH
+ CI
+ FORWARD_SLASH);
processor.changeNodeValue("smtpAuthUsername", job.getSenderEmailId());
processor.changeNodeValue("smtpAuthPassword", job.getSenderEmailPassword());
processor.changeNodeValue("adminAddress", job.getSenderEmailId());
// jenkins home location
String jenkinsJobHome = System.getenv(JENKINS_HOME);
StringBuilder builder = new StringBuilder(jenkinsJobHome);
builder.append(File.separator);
processor.writeStream(new File(builder.toString() + CI_MAILER_XML));
} catch (Exception e) {
S_LOGGER.error(
"Entered into the catch block of CIManagerImpl.setMailCredential "
+ e.getLocalizedMessage());
}
}
public void summaryAction(HttpServletRequest req, HttpServletResponse res) {
if (AccountController.redirectIfNoCookie(req, res)) return;
Map<String, Object> viewData = new HashMap<String, Object>();
DocumentManager docMan = new DocumentManager();
try {
if (req.getParameter("documentId") != null) {
// Get the document ID
int docId = Integer.parseInt(req.getParameter("documentId"));
// Get the document using document id
Document document = docMan.get(docId);
// Set title to name of the document
viewData.put("title", document.getDocumentName());
// Create List of access records
List<AccessRecord> accessRecords = new LinkedList<AccessRecord>();
// Add access records for document to the list
accessRecords = docMan.getAccessRecords(docId);
viewData.put("accessRecords", accessRecords);
} else {
// Go back to thread page.
}
} catch (Exception e) {
Logger.getLogger("").log(Level.SEVERE, "An error occurred when getting profile user", e);
}
view(req, res, "/views/group/Document.jsp", viewData);
}
protected void log(Logger logger, Level level, Method method, Object[] args, long timeNanoSec) {
if (logger.isLoggable(level)) {
String message = buildMessage(method, args, timeNanoSec);
log(logger, level, message);
}
}
/**
* Returns the cached recent messages history.
*
* @return
* @throws IOException
*/
private History getHistory() throws IOException {
synchronized (historyID) {
HistoryService historyService =
MessageHistoryActivator.getMessageHistoryService().getHistoryService();
if (history == null) {
history = historyService.createHistory(historyID, recordStructure);
// lets check the version if not our version, re-create
// history (delete it)
HistoryReader reader = history.getReader();
boolean delete = false;
QueryResultSet<HistoryRecord> res = reader.findLast(1);
if (res != null && res.hasNext()) {
HistoryRecord hr = res.next();
if (hr.getPropertyValues().length >= 4) {
if (!hr.getPropertyValues()[3].equals(RECENT_MSGS_VER)) delete = true;
} else delete = true;
}
if (delete) {
// delete it
try {
historyService.purgeLocallyStoredHistory(historyID);
history = historyService.createHistory(historyID, recordStructure);
} catch (IOException ex) {
logger.error("Cannot delete recent_messages history", ex);
}
}
}
return history;
}
}
/**
* Populates a specific <tt>Request</tt> instance with the headers common to dialog-creating
* <tt>Request</tt>s and ones sent inside existing dialogs and specific to the general event
* package subscription functionality that this instance and a specific <tt>Subscription</tt>
* represent.
*
* @param req the <tt>Request</tt> instance to be populated with common headers and ones specific
* to the event package of a specific <tt>Subscription</tt>
* @param subscription the <tt>Subscription</tt> which is to be described in the specified
* <tt>Request</tt> i.e. its properties are to be used to populate the specified
* <tt>Request</tt>
* @param expires the subscription duration to be set into the Expires header of the specified
* SUBSCRIBE <tt>Request</tt>
* @throws OperationFailedException if we fail parsing or populating the subscription request.
*/
protected void populateSubscribeRequest(Request req, Subscription subscription, int expires)
throws OperationFailedException {
HeaderFactory headerFactory = protocolProvider.getHeaderFactory();
// Event
EventHeader evHeader;
try {
evHeader = headerFactory.createEventHeader(eventPackage);
String eventId = subscription.getEventId();
if (eventId != null) evHeader.setEventId(eventId);
} catch (ParseException e) {
// these two should never happen.
logger.error("An unexpected error occurred while" + "constructing the EventHeader", e);
throw new OperationFailedException(
"An unexpected error occurred while" + "constructing the EventHeader",
OperationFailedException.INTERNAL_ERROR,
e);
}
req.setHeader(evHeader);
// Accept
AcceptHeader accept;
try {
accept = headerFactory.createAcceptHeader("application", contentSubType);
} catch (ParseException e) {
logger.error("wrong accept header", e);
throw new OperationFailedException(
"An unexpected error occurred while" + "constructing the AcceptHeader",
OperationFailedException.INTERNAL_ERROR,
e);
}
req.setHeader(accept);
// Expires
ExpiresHeader expHeader;
try {
expHeader = headerFactory.createExpiresHeader(expires);
} catch (InvalidArgumentException e) {
logger.error("Invalid expires value: " + expires, e);
throw new OperationFailedException(
"An unexpected error occurred while" + "constructing the ExpiresHeader",
OperationFailedException.INTERNAL_ERROR,
e);
}
req.setHeader(expHeader);
}
private int getProgressInBuild(CIJob job) throws PhrescoException {
S_LOGGER.debug("Entering Method CIManagerImpl.isBuilding(CIJob job)");
String jenkinsUrl =
HTTP_PROTOCOL
+ PROTOCOL_POSTFIX
+ job.getJenkinsUrl()
+ COLON
+ job.getJenkinsPort()
+ FORWARD_SLASH
+ CI
+ FORWARD_SLASH;
String isBuildingUrlUrl = BUSY_EXECUTORS;
String jsonResponse = getJsonResponse(jenkinsUrl + isBuildingUrlUrl);
int buidInProgress = Integer.parseInt(jsonResponse);
S_LOGGER.debug("buidInProgress " + buidInProgress);
return buidInProgress;
}
public void run() {
// ///////////////////////////
Gateway.addLiveThread(this);
// ///////////////////////////
while (Gateway.running) {
try {
pdud = (PDUData) fromSMSC.dequeue(); // blocks until having
// an item
// pdu = (PDU) fromSMSC.dequeue(); //blocks until having an item
pdu = (PDU) pdud.getPDU();
if (pdu.isRequest()) {
this.RequestID = pdud.getRequestID();
processRequest(pdu);
}
} catch (DBException ex) { // when lost connection to db
Logger.error(this.getClass().getName(), "DBException: " + ex.getMessage());
DBTools.ALERT(
"RequestProcessor",
"RequestProcessor",
Constants.ALERT_WARN,
Preference.Channel + "DBException: " + ex.getMessage(),
Preference.ALERT_CONTACT);
Logger.error(this.getClass().getName(), "Alert2YM DBException: " + ex.getMessage());
} catch (Exception e) {
Logger.error(this.getClass().getName(), "Exception: " + e.getMessage());
DBTools.ALERT(
"RequestProcessor",
"RequestProcessor",
Constants.ALERT_WARN,
Preference.Channel + "Exception: " + e.getMessage(),
Preference.ALERT_CONTACT);
}
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// /////////////////////////////
Logger.info(this.getClass().getName(), "{" + this.getClass().getName() + " stopped}");
this.destroy();
// /////////////////////////////
}
private CIJob getJob(ApplicationInfo appInfo) throws PhrescoException {
Gson gson = new Gson();
try {
BufferedReader br = new BufferedReader(new FileReader(getCIJobPath(appInfo)));
CIJob job = gson.fromJson(br, CIJob.class);
br.close();
return job;
} catch (FileNotFoundException e) {
S_LOGGER.debug(e.getLocalizedMessage());
return null;
} catch (com.google.gson.JsonParseException e) {
S_LOGGER.debug("it is already adpted project !!!!! " + e.getLocalizedMessage());
return null;
} catch (IOException e) {
S_LOGGER.debug(e.getLocalizedMessage());
return null;
}
}
public int getTotalBuilds(ApplicationInfo appInfo) throws PhrescoException {
try {
CIJob ciJob = getJob(appInfo);
return getTotalBuilds(ciJob);
} catch (ClientHandlerException ex) {
S_LOGGER.error(ex.getLocalizedMessage());
throw new PhrescoException(ex);
}
}
/**
* Sends the <tt>message</tt> to the destination indicated by the <tt>to</tt> contact.
*
* @param to the <tt>Contact</tt> to send <tt>message</tt> to
* @param message the <tt>Message</tt> to send.
* @throws java.lang.IllegalStateException if the underlying stack is not registered and
* initialized.
* @throws java.lang.IllegalArgumentException if <tt>to</tt> is not an instance of ContactImpl.
*/
public void sendInstantMessage(Contact to, Message message)
throws IllegalStateException, IllegalArgumentException {
if (!(to instanceof ContactSipImpl))
throw new IllegalArgumentException("The specified contact is not a Sip contact." + to);
assertConnected();
// offline message
if (to.getPresenceStatus().equals(sipStatusEnum.getStatus(SipStatusEnum.OFFLINE))
&& !offlineMessageSupported) {
if (logger.isDebugEnabled()) logger.debug("trying to send a message to an offline contact");
fireMessageDeliveryFailed(
message, to, MessageDeliveryFailedEvent.OFFLINE_MESSAGES_NOT_SUPPORTED);
return;
}
// create the message
Request mes;
try {
mes = createMessageRequest(to, message);
} catch (OperationFailedException ex) {
logger.error("Failed to create the message.", ex);
fireMessageDeliveryFailed(message, to, MessageDeliveryFailedEvent.INTERNAL_ERROR);
return;
}
try {
sendMessageRequest(mes, to, message);
} catch (TransactionUnavailableException ex) {
logger.error(
"Failed to create messageTransaction.\n"
+ "This is most probably a network connection error.",
ex);
fireMessageDeliveryFailed(message, to, MessageDeliveryFailedEvent.NETWORK_FAILURE);
return;
} catch (SipException ex) {
logger.error("Failed to send the message.", ex);
fireMessageDeliveryFailed(message, to, MessageDeliveryFailedEvent.INTERNAL_ERROR);
return;
}
}
/**
* stores the data to a HTML file
*
* @param aFile file object
*/
private void storeToHtmlFile(final File aFile, final UARTDataSet aDataSet) {
try {
toHtmlPage(aFile, aDataSet);
} catch (final IOException exception) {
// Make sure to handle IO-interrupted exceptions properly!
if (!HostUtils.handleInterruptedException(exception)) {
LOG.log(Level.WARNING, "HTML export failed!", exception);
}
}
}
public List<CIJob> getJobs(ApplicationInfo appInfo) throws PhrescoException {
S_LOGGER.debug("GetJobs Called!");
try {
boolean adaptedProject = adaptExistingJobs(appInfo);
S_LOGGER.debug("Project adapted for new feature => " + adaptedProject);
Gson gson = new Gson();
BufferedReader br = new BufferedReader(new FileReader(getCIJobPath(appInfo)));
Type type = new TypeToken<List<CIJob>>() {}.getType();
List<CIJob> jobs = gson.fromJson(br, type);
br.close();
return jobs;
} catch (FileNotFoundException e) {
S_LOGGER.debug("FileNotFoundException");
return null;
} catch (IOException e) {
S_LOGGER.debug("IOException");
throw new PhrescoException(e);
}
}
public static void setLocale(Locale locale) {
_formats = new Hashtable();
try {
if (locale == null) _messages = ResourceBundle.getBundle(ResourceName);
else _messages = ResourceBundle.getBundle(ResourceName, locale);
} catch (Exception except) {
_messages = new EmptyResourceBundle();
Logger.getSystemLogger().println("Failed to locate messages resource " + ResourceName);
}
}
public void registerListener(int id, MessageListener m) {
HashSet listenerSet = (HashSet) idTable.get(new Integer(id));
if (listenerSet == null) {
listenerSet = new HashSet();
idTable.put(new Integer(id), listenerSet);
}
listenerSet.add(m);
log.info("New Listener for id=" + id);
}
public ClientThread(Socket socket, History history, Users users) throws IOException {
logger.warn("New client is trying to connect to the chat...");
logger.info("Assigning a socket to a new client...");
this.s = socket;
logger.info("Getting the input stream...");
in = new DataInputStream(s.getInputStream());
logger.info("Getting the output stream...");
out = new DataOutputStream(s.getOutputStream());
this.users = users;
users.addObserver(this);
this.history = history;
start();
logger.warn("Connection with new user is established.");
}
private InputStream getInputStream(
String urlStr, Format outputFormat, ContentDescriptor outputContentDescriptor)
throws Exception {
final ProcessorModel processorModel =
new ProcessorModel(
new MediaLocator(urlStr),
outputFormat == null ? null : new Format[] {outputFormat},
outputContentDescriptor);
final Processor processor = Manager.createRealizedProcessor(processorModel);
final DataSource ds = processor.getDataOutput();
final DataSink[] streamDataSinkHolder = new DataSink[] {null};
// connect the data output of the processor to a StreamDataSink, which
// will make the data available to PipedInputStream, which we return.
final PipedInputStream in =
new PipedInputStream() {
// override close to clean up everything when the media has been
// served.
@Override
public void close() throws IOException {
super.close();
logger.fine("Closed input stream");
logger.fine("Stopping processor");
processor.stop();
logger.fine("Closing processor");
processor.close();
logger.fine("Deallocating processor");
processor.deallocate();
if (streamDataSinkHolder[0] != null) {
logger.fine("Closing StreamDataSink");
streamDataSinkHolder[0].close();
}
}
};
final PipedOutputStream out = new PipedOutputStream(in);
final DataSink streamDataSink = new StreamDataSink(out);
streamDataSinkHolder[0] = streamDataSink;
streamDataSink.setSource(ds);
streamDataSink.open();
streamDataSink.start();
logger.info("Starting processor");
processor.start();
// TODO: if there is an error, make sure we clean up.
// for example, if the client breaks the connection.
// we need a controller listener to listen for errors.
return in;
}
public CIJobStatus deleteJobs(ApplicationInfo appInfo, List<String> jobNames)
throws PhrescoException {
S_LOGGER.debug("Entering Method ProjectAdministratorImpl.deleteCI()");
try {
CIJobStatus deleteCI = null;
for (String jobName : jobNames) {
S_LOGGER.debug(" Deleteable job name " + jobName);
CIJob ciJob = getJob(appInfo, jobName);
// job and build numbers
deleteCI = deleteCI(ciJob, null);
S_LOGGER.debug("write back json data after job deletion successfull");
deleteJsonJobs(appInfo, Arrays.asList(ciJob));
}
return deleteCI;
} catch (ClientHandlerException ex) {
S_LOGGER.error(
"Entered into catch block of ProjectAdministratorImpl.deleteCI()"
+ ex.getLocalizedMessage());
throw new PhrescoException(ex);
}
}
public void run() {
try {
prepareClient();
logger.info("Starting normal session with " + getClientName());
while (true) {
this.receive();
}
} catch (IOException ioe) {
logger.warn("Client " + this + " has been disconnected.");
this.setDisabled(true);
users.remove(this);
} finally {
try {
if (s != null && !s.isClosed()) {
s.close();
logger.warn("Socket with " + this + " has been closed.");
}
} catch (IOException ioe) {
logger.error("Socket has not been closed.", ioe);
}
}
}
