@ManagedOperation(description="Dumps all pending requests") public String dumpPendingRequests() { StringBuilder sb=new StringBuilder(); for(Tuple<Request,Promise> tuple: pending_requests.values()) { Request tmp=tuple.getVal1(); sb.append(tmp + " (" + tmp.getClass().getCanonicalName() + ") "); } return sb.toString(); }
@ManagedOperation(description="Prints suspect history") public String printSuspectHistory() { StringBuilder sb=new StringBuilder(); for(Tuple<Address,Long> tmp: suspect_history) { sb.append(new Date(tmp.getVal2())).append(": ").append(tmp.getVal1()).append("\n"); } return sb.toString(); }
@ManagedOperation(description="Prints suspect history") public String printSuspectHistory() { StringBuilder sb=new StringBuilder(); for(Tuple<Address,Long> tmp: suspect_history) { sb.append(new Date(tmp.getVal2())).append(": ").append(tmp.getVal1()).append("\n"); } return sb.toString(); }
@ManagedOperation(description="Prints history of suspected hosts") public String printSuspectHistory() { StringBuilder sb=new StringBuilder(); for(Tuple<InetAddress,Long> tmp: suspect_history) { sb.append(new Date(tmp.getVal2())).append(": ").append(tmp.getVal1()).append("\n"); } return sb.toString(); }
@ManagedOperation(description="Prints all currently installed rules") public String dumpRules() { StringBuilder sb=new StringBuilder(); for(Map.Entry<String,Tuple<Rule,Future<?>>> entry: rules.entrySet()) { String key=entry.getKey(); Tuple<Rule,Future<?>> tuple=entry.getValue(); Rule rule=tuple.getVal1(); sb.append(key + ": " + rule.description() + "\n"); } return sb.toString(); }
public static long readBytesLong(String input) { Tuple<String,Long> tuple=readBytes(input); double num=Double.parseDouble(tuple.getVal1()); return (long)(num * tuple.getVal2()); }
public static double readBytesDouble(String input) { Tuple<String,Long> tuple=readBytes(input); double num=Double.parseDouble(tuple.getVal1()); return num * tuple.getVal2(); }
public static int readBytesInteger(String input) { Tuple<String,Long> tuple=readBytes(input); double num=Double.parseDouble(tuple.getVal1()); return (int)(num * tuple.getVal2()); }
@ManagedOperation(description="Uninstalls the named rule") public void uninstallRule(String name) { if(name != null) { Tuple<Rule,Future<?>> tuple=rules.remove(name); if(tuple != null) { tuple.getVal2().cancel(true); tuple.getVal1().destroy(); } } }
public void writeTo(DataOutput out) throws Exception { if(existing_locks == null) out.writeInt(0); else { out.writeInt(existing_locks.size()); for(Tuple<String,Owner> t: existing_locks) { Bits.writeString(t.getVal1(), out); t.getVal2().writeTo(out); } } if(pending_requests == null) out.writeInt(0); else { out.writeInt(pending_requests.size()); for(Request req: pending_requests) req.writeTo(out); } }
protected void removeFromAddressMappings(Address client_addr) { if(client_addr == null) return; Set<Tuple<String,Address>> suspects=null; // group/address pairs for(Map.Entry<String,ConcurrentMap<Address,Entry>> entry: address_mappings.entrySet()) { ConcurrentMap<Address,Entry> map=entry.getValue(); for(Map.Entry<Address,Entry> entry2: map.entrySet()) { Entry e=entry2.getValue(); if(client_addr.equals(e.client_addr)) { map.remove(entry2.getKey()); log.debug("connection to %s closed", client_addr); if(map.isEmpty()) address_mappings.remove(entry.getKey()); if(suspects == null) suspects=new HashSet<>(); suspects.add(new Tuple<>(entry.getKey(), entry2.getKey())); break; } } } if(emit_suspect_events && suspects != null && !suspects.isEmpty()) { for(Tuple<String,Address> suspect: suspects) { String group=suspect.getVal1(); Address addr=suspect.getVal2(); ConcurrentMap<Address,Entry> map=address_mappings.get(group); if(map == null) continue; GossipData data=new GossipData(GossipType.SUSPECT, group, addr); sendToAllMembersInGroup(map.entrySet(), data); } } }
public Object down(Event evt) { Object retval=super.down(evt); switch(evt.type()) { case Event.ADD_PHYSICAL_ADDRESS: Tuple<Address,PhysicalAddress> tuple=evt.arg(); IpAddress val=(IpAddress)tuple.getVal2(); addr_table.put(tuple.getVal1(), new InetSocketAddress(val.getIpAddress(), val.getPort())); break; case Event.VIEW_CHANGE: for(Iterator<Map.Entry<Address,SocketAddress>> it=addr_table.entrySet().iterator(); it.hasNext();) { Map.Entry<Address,SocketAddress> entry=it.next(); if(!view.containsMember(entry.getKey())) { SocketAddress sock_addr=entry.getValue(); it.remove(); Connection conn=connections.remove(sock_addr); Util.close(conn); } } break; } return retval; }
/** * Checks the sent table: if some credits are in queueing mode and credits left are less than min_credits: * send a credit request */ protected void sendCreditRequestsIfNeeded() { if(credits.getMinCredits() < min_credits && needToSendCreditRequest()) { List<Tuple<Address,Long>> targets=credits.getMembersWithCreditsLessThan(min_credits); for(Tuple<Address,Long> tuple: targets) sendCreditRequest(tuple.getVal1(), Math.min(max_credits, max_credits - tuple.getVal2())); } }
return; byte[] version=tuple.getVal2(); byte[] secret_key=tuple.getVal1().getEncoded();
protected void handleSecretKeyRequest(PublicKey dh_public_key, Address sender) throws Exception { KeyPair kp=key_pair_gen.generateKeyPair(); PrivateKey private_key=kp.getPrivate(); PublicKey public_key_rsp=kp.getPublic(); // sent back as part of the response byte[] version; byte[] encrypted_secret_key; log.debug("%s: received public key %s.. from %s", local_addr, print16(dh_public_key), sender); synchronized(this) { key_agreement.init(private_key); key_agreement.doPhase(dh_public_key, true); // Diffie-Hellman secret session key, to encrypt secret key byte[] secret_session_key=key_agreement.generateSecret(); SecretKey hashed_session_key=hash(secret_session_key); Cipher encrypter=Cipher.getInstance(secret_key_algorithm); encrypter.init(Cipher.ENCRYPT_MODE, hashed_session_key); Tuple<SecretKey,byte[]> tuple=(Tuple<SecretKey,byte[]>)up_prot.up(new Event(Event.GET_SECRET_KEY)); SecretKey secret_key=tuple.getVal1(); version=tuple.getVal2(); encrypted_secret_key=encrypter.doFinal(secret_key.getEncoded()); } log.debug("%s: sending public key rsp %s.. to %s", local_addr, print16(public_key_rsp), sender); // send response to sender with public_key_rsp, encrypted secret key and secret key version Message rsp=new Message(sender) .putHeader(id, DhHeader.createSecretKeyResponse(public_key_rsp.getEncoded(), encrypted_secret_key, version)); down_prot.down(rsp); }
public Object up(Event evt) { switch(evt.type()) { case Event.GET_SECRET_KEY: return new Tuple<>(secret_key, sym_version); case Event.SET_SECRET_KEY: Tuple<SecretKey,byte[]> tuple=evt.arg(); try { setKeys(null, tuple.getVal1(), tuple.getVal2()); } catch(Exception ex) { log.error("failed setting secret key", ex); } return null; } return up_prot.up(evt); }
@Override protected Object handleDownMessage(final Message msg) { Address dest=msg.dest(); if(dest != null) // 2nd line of defense, not really needed return down_prot.down(msg); int length=msg.length(); if(running) { if(credits.decrement(msg, length, 0)) // timeout is ignored return down_prot.down(msg); // message was queued if(needToSendCreditRequest()) { List<Tuple<Address,Long>> targets=credits.getMembersWithCreditsLessThan(min_credits); for(Tuple<Address,Long> tuple: targets) sendCreditRequest(tuple.getVal1(), Math.min(max_credits, max_credits - tuple.getVal2())); } return null; } return down_prot.down(msg); }
@Override protected Object handleDownMessage(final Message msg) { Address dest=msg.dest(); if(dest != null) // 2nd line of defense, not really needed return down_prot.down(msg); int length=msg.length(); long block_time=max_block_times != null? getMaxBlockTime(length) : max_block_time; while(running) { boolean rc=credits.decrement(msg, length, block_time); if(rc || max_block_times != null || !running) break; if(needToSendCreditRequest()) { List<Tuple<Address,Long>> targets=credits.getMembersWithCreditsLessThan(min_credits); for(Tuple<Address,Long> tuple: targets) sendCreditRequest(tuple.getVal1(), Math.min(max_credits, max_credits - tuple.getVal2())); } } // send message - either after regular processing, or after blocking (when enough credits are available again) return down_prot.down(msg); }
private void handleStartFlush(Message msg, FlushHeader fh) { Address flushRequester = msg.getSrc(); boolean proceed = flushInProgress.compareAndSet(false, true); if (proceed) { synchronized (sharedLock) { flushCoordinator = flushRequester; } onStartFlush(flushRequester, msg, fh); } else { Tuple<Collection<? extends Address>,Digest> tuple=readParticipantsAndDigest(msg.getRawBuffer(), msg.getOffset(),msg.getLength()); Collection<? extends Address> flushParticipants=tuple.getVal1(); Message response = new Message(flushRequester) .putHeader(this.id,new FlushHeader(FlushHeader.FLUSH_NOT_COMPLETED,fh.viewID)) .setBuffer(marshal(flushParticipants,null)); down_prot.down(response); if (log.isDebugEnabled()) log.debug(localAddress + ": received START_FLUSH, responded with FLUSH_NOT_COMPLETED to " + flushRequester); } }
try { in=tuple.getVal1(); resource=tuple.getVal2();