public List<PingData> get(long timeout) throws InterruptedException {
long start_time = System.currentTimeMillis(), time_to_wait = timeout;
promise.getLock().lock();
try {
while (time_to_wait > 0 && !promise.hasResult()) {
// if num_expected_srv_rsps > 0, then it overrides num_expected_rsps
if (num_expected_srv_rsps > 0) {
int received_srv_rsps = getNumServerResponses(ping_rsps);
if (received_srv_rsps >= num_expected_srv_rsps)
return new LinkedList<PingData>(ping_rsps);
} else if (ping_rsps.size() >= num_expected_rsps) {
return new LinkedList<PingData>(ping_rsps);
}
if (break_on_coord_rsp && containsCoordinatorResponse(ping_rsps))
return new LinkedList<PingData>(ping_rsps);
promise.getCond().await(time_to_wait, TimeUnit.MILLISECONDS);
time_to_wait = timeout - (System.currentTimeMillis() - start_time);
}
return new LinkedList<PingData>(ping_rsps);
} finally {
promise.getLock().unlock();
}
}
protected void getState(Address target, long timeout, Callable<Boolean> flushInvoker)
throws Exception {
checkClosedOrNotConnected();
if (!state_transfer_supported)
throw new IllegalStateException(
"fetching state will fail as state transfer is not supported. "
+ "Add one of the state transfer protocols to your configuration");
if (target == null) target = determineCoordinator();
if (target != null && local_addr != null && target.equals(local_addr)) {
log.trace(
local_addr
+ ": cannot get state from myself ("
+ target
+ "): probably the first member");
return;
}
boolean initiateFlush = flushSupported() && flushInvoker != null;
if (initiateFlush) {
boolean successfulFlush = false;
try {
successfulFlush = flushInvoker.call();
} catch (Throwable e) {
successfulFlush = false; // http://jira.jboss.com/jira/browse/JGRP-759
}
if (!successfulFlush)
throw new IllegalStateException(
"Node " + local_addr + " could not flush the cluster for state retrieval");
}
state_promise.reset();
StateTransferInfo state_info = new StateTransferInfo(target, timeout);
long start = System.currentTimeMillis();
down(new Event(Event.GET_STATE, state_info));
StateTransferResult result = state_promise.getResult(state_info.timeout);
if (initiateFlush) stopFlush();
if (result == null)
throw new StateTransferException(
"timeout during state transfer (" + (System.currentTimeMillis() - start) + "ms)");
if (result.hasException())
throw new StateTransferException("state transfer failed", result.getException());
}
public JiraTickets tickets() throws ExecutionException, InterruptedException {
List<JiraTicket> jiraTickets = new ArrayList<JiraTicket>();
for (BasicIssue issuesKey : issuesKeys) {
Promise<Issue> issuePromise = issueRestClient.getIssue(issuesKey.getKey());
Issue i = issuePromise.get();
JiraTicket ticket =
new JiraTicket(
i.getKey(),
field(i, HOTFIX_TO),
field(i, FIX_DETAILS),
field(i, HOTFIX_FILES),
field(i, HOTFIX_INSTRUCTIONS),
field(i, HOTFIX_APPROVED_BY),
field(i, VERIFICATION_DETAILS));
jiraTickets.add(ticket);
}
return new JiraTickets(jiraTickets);
}
private static Result wrapScalaResult(
scala.concurrent.Future<play.api.mvc.Result> result, long timeout) {
if (result == null) {
return null;
} else {
final play.api.mvc.Result scalaResult = Promise.wrap(result).get(timeout);
return scalaResult.asJava();
}
}
public void uploadAttachments(JiraTickets tickets)
throws ExecutionException, InterruptedException, IOException {
for (JiraTicket t : tickets) {
Promise<Issue> issuePromise = issueRestClient.getIssue(t.getId());
Issue i = issuePromise.get();
File rollback = t.getRollback();
File hotfix = t.getHotfix();
if (rollback != null && rollback.canRead()) {
issueRestClient.addAttachment(
i.getAttachmentsUri(), FileUtils.openInputStream(rollback), rollback.getName());
}
if (hotfix != null && hotfix.canRead()) {
issueRestClient.addAttachment(
i.getAttachmentsUri(), FileUtils.openInputStream(hotfix), hotfix.getName());
}
}
}
public void updateTickets(JiraTickets tickets) throws ExecutionException, InterruptedException {
for (JiraTicket t : tickets) {
Promise<Issue> issuePromise = issueRestClient.getIssue(t.getId());
Issue i = issuePromise.get();
// find transition (we need ID)
Iterable<Transition> transitions =
issueRestClient.getTransitions(i.getTransitionsUri()).get();
String tName = "Hotfix Failed";
if (t.isValid()) {
tName = "Out On Dev";
}
Transition transition = find(transitions, tName);
if (transition == null) {
continue;
}
// prepare fields
// List<FieldInput> fields = Arrays.asList( new FieldInput("resolution",
// ComplexIssueInputFieldValue.with("name", "RerunPass")));
Comment comment = Comment.valueOf(StringUtils.join(t.getValidationMessages(), "\n"));
issueRestClient.transition(i, new TransitionInput(transition.getId(), comment));
}
}
public void sendDiscoveryRequest(String cluster_name, Promise promise, ViewId view_id)
throws Exception {
PingData data = null;
PhysicalAddress physical_addr =
(PhysicalAddress) down(new Event(Event.GET_PHYSICAL_ADDRESS, local_addr));
if (view_id == null) {
List<PhysicalAddress> physical_addrs = Arrays.asList(physical_addr);
data = new PingData(local_addr, null, false, UUID.get(local_addr), physical_addrs);
}
PingHeader hdr = new PingHeader(PingHeader.GET_MBRS_REQ, data, cluster_name);
hdr.view_id = view_id;
Collection<PhysicalAddress> cluster_members = fetchClusterMembers(cluster_name);
if (cluster_members == null) {
Message msg = new Message(null); // multicast msg
msg.setFlag(Message.OOB);
msg.putHeader(getId(), hdr);
sendMcastDiscoveryRequest(msg);
} else {
if (cluster_members.isEmpty()) { // if we don't find any members, return immediately
if (promise != null) promise.setResult(null);
} else {
for (final Address addr : cluster_members) {
if (addr.equals(physical_addr)) // no need to send the request to myself
continue;
final Message msg = new Message(addr, null, null);
msg.setFlag(Message.OOB);
msg.putHeader(this.id, hdr);
if (log.isTraceEnabled())
log.trace("[FIND_INITIAL_MBRS] sending discovery request to " + msg.getDest());
if (!sendDiscoveryRequestsInParallel()) {
down_prot.down(new Event(Event.MSG, msg));
} else {
timer.execute(
new Runnable() {
public void run() {
try {
down_prot.down(new Event(Event.MSG, msg));
} catch (Exception ex) {
if (log.isErrorEnabled())
log.error("failed sending discovery request to " + addr + ": " + ex);
}
}
});
}
}
}
}
}
public void addResponse(PingData rsp, boolean overwrite) {
if (rsp == null) return;
promise.getLock().lock();
try {
if (overwrite) ping_rsps.remove(rsp);
// https://jira.jboss.org/jira/browse/JGRP-1179
int index = ping_rsps.indexOf(rsp);
if (index == -1) {
ping_rsps.add(rsp);
promise.getCond().signalAll();
} else if (rsp.isCoord()) {
PingData pr = ping_rsps.get(index);
// Check if the already existing element is not server
if (!pr.isCoord()) {
ping_rsps.set(index, rsp);
promise.getCond().signalAll();
}
}
} finally {
promise.getLock().unlock();
}
}
/**
* Callback method <br>
* Called by the ProtocolStack when a message is received.
*
* @param evt the event carrying the message from the protocol stack
*/
public Object up(Event evt) {
switch (evt.getType()) {
case Event.MSG:
Message msg = (Message) evt.getArg();
if (stats) {
received_msgs++;
received_bytes += msg.getLength();
}
// discard local messages (sent by myself to me)
if (discard_own_messages
&& local_addr != null
&& msg.getSrc() != null
&& local_addr.equals(msg.getSrc())) return null;
break;
case Event.VIEW_CHANGE:
View tmp = (View) evt.getArg();
if (tmp instanceof MergeView) my_view = new View(tmp.getViewId(), tmp.getMembers());
else my_view = tmp;
// Bela&Vladimir Oct 27th,2006 (JGroups 2.4): we need to set connected=true because a client
// can
// call channel.getView() in viewAccepted() callback invoked on this thread (see
// Event.VIEW_CHANGE handling below)
// not good: we are only connected when we returned from connect() - bela June 22 2007
// Changed: when a channel gets a view of which it is a member then it should be
// connected even if connect() hasn't returned yet ! (bela Noc 2010)
if (state != State.CONNECTED) state = State.CONNECTED;
break;
case Event.CONFIG:
Map<String, Object> cfg = (Map<String, Object>) evt.getArg();
if (cfg != null) {
if (cfg.containsKey("state_transfer")) {
state_transfer_supported = (Boolean) cfg.get("state_transfer");
}
if (cfg.containsKey("flush_supported")) {
flush_supported = (Boolean) cfg.get("flush_supported");
}
}
break;
case Event.GET_STATE_OK:
StateTransferResult result = (StateTransferResult) evt.getArg();
if (up_handler != null) {
try {
Object retval = up_handler.up(evt);
state_promise.setResult(new StateTransferResult());
return retval;
} catch (Throwable t) {
state_promise.setResult(new StateTransferResult(t));
}
}
if (receiver != null) {
try {
if (result.hasBuffer()) {
byte[] tmp_state = result.getBuffer();
ByteArrayInputStream input = new ByteArrayInputStream(tmp_state);
receiver.setState(input);
}
state_promise.setResult(result);
} catch (Throwable t) {
state_promise.setResult(new StateTransferResult(t));
}
}
break;
case Event.STATE_TRANSFER_INPUTSTREAM_CLOSED:
state_promise.setResult((StateTransferResult) evt.getArg());
break;
case Event.STATE_TRANSFER_INPUTSTREAM:
// Oct 13,2006 moved to down() when Event.STATE_TRANSFER_INPUTSTREAM_CLOSED is received
// state_promise.setResult(is != null? Boolean.TRUE : Boolean.FALSE);
if (up_handler != null) return up_handler.up(evt);
InputStream is = (InputStream) evt.getArg();
if (is != null && receiver != null) {
try {
receiver.setState(is);
} catch (Throwable t) {
throw new RuntimeException("failed calling setState() in state requester", t);
}
}
break;
case Event.STATE_TRANSFER_OUTPUTSTREAM:
if (receiver != null && evt.getArg() != null) {
try {
receiver.getState((OutputStream) evt.getArg());
} catch (Exception e) {
throw new RuntimeException("failed calling getState() in state provider", e);
}
}
break;
case Event.GET_LOCAL_ADDRESS:
return local_addr;
default:
break;
}
// If UpHandler is installed, pass all events to it and return (UpHandler is e.g. a building
// block)
if (up_handler != null) return up_handler.up(evt);
if (receiver != null) return invokeCallback(evt.getType(), evt.getArg());
return null;
}