public int compareTo(ClientLock o) { int rc=owner.compareTo(o.owner); return rc != 0? rc : name.compareTo(o.name); } }
/** Checks if a certain request from a given owner is already in the queue */ protected boolean isRequestPresent(Type type, Owner owner) { // holds lock on queue for(Request req: queue) if(req.type == type && req.owner.equals(owner)) return true; return false; }
protected Owner getOwner() { return new Owner(local_addr, Thread.currentThread().getId()); }
protected Response handleView(List<Address> members) { if(owner != null && !members.contains(owner.getAddress())) { Owner tmp=owner; setOwner(null); log.debug("%s: unlocked \"%s\" because owner %s left", local_addr, lock_name, tmp); } synchronized(queue) { queue.removeIf(req -> !members.contains(req.owner.getAddress())); } condition.queue.removeIf(own -> !members.contains(own.getAddress())); return processQueue(); }
public void writeTo(DataOutput out) throws Exception { owner.writeTo(out); Bits.writeLong(version, out); }
protected Owner getOwner() { return new Owner(local_addr, Thread.currentThread().getId()); }
protected void sendSignalResponse(Owner dest, String lock_name) { send(dest.getAddress(), new Request(Type.SIG_RET, lock_name, dest, 0)); }
public void writeTo(DataOutput out) throws Exception { owner.writeTo(out); Bits.writeString(name,out); }
protected void removeRequest(Type type, Owner owner) { synchronized(queue) { queue.removeIf(req -> req.type == type && req.owner.equals(owner)); } }
protected Owner getOwner() { return use_thread_id_for_lock_owner? super.getOwner(): new Owner(local_addr, -1); }
protected void sendLockResponse(Type type, Owner dest, String lock_name, int lock_id) { send(dest.getAddress(), new Request(type, lock_name, dest, 0).lockId(lock_id)); }
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); } }
public int compareTo(ClientLock o) { int rc=owner.compareTo(o.owner); return rc != 0? rc : name.compareTo(o.name); } }
public void readFrom(DataInput in) throws Exception { int size=in.readInt(); if(size > 0) { existing_locks=new ArrayList<>(size); for(int i=0; i < size; i++) { String lock_name=Bits.readString(in); Owner owner=new Owner(); owner.readFrom(in); existing_locks.add(new Tuple<>(lock_name, owner)); } } size=in.readInt(); if(size > 0) { pending_requests=new ArrayList<>(); for(int i=0; i < size; i++) { Request req=new Request(); req.readFrom(in); pending_requests.add(req); } } }
protected Response processQueue() { if(owner != null) return null; Request req; while((req=getNextRequest()) != null) { switch(req.type) { case GRANT_LOCK: setOwner(req.owner); return new Response(Type.LOCK_GRANTED, req.owner, req.lock_name, req.lock_id); case RELEASE_LOCK: if(owner == null) break; if(owner.equals(req.owner)) setOwner(null); return new Response(Type.RELEASE_LOCK_OK, req.owner, req.lock_name, req.lock_id); } } return null; }
protected Owner getOwner() { return use_thread_id_for_lock_owner? super.getOwner(): new Owner(local_addr, -1); }
if(!Objects.equals(owner, ret.owner)) { log.warn("%s: lock %s requested by %s is already present: %s", local_addr, lock_name, owner, ret); send(owner.getAddress(), new Request(Type.LOCK_REVOKED, lock_name, ret.owner, 0));
public void writeTo(DataOutput out) throws Exception { owner.writeTo(out); Bits.writeString(name,out); }