// checks for old locks, and removes them
public void Tick()
{
ArrayList RemovedLocks = new ArrayList();
foreach (DictionaryEntry entry in locks)
{
LockInfo lockinfo = (LockInfo)entry.Value;
if (lockinfo.Timestamp.Subtract(DateTime.Now).Milliseconds > LockTimeoutSeconds * 1000)
{
NetworkInterfaces.IReplicated targetobject = lockinfo.TargetObject;
if (IsMaster)
{
object clientconnection = lockinfo.Requester;
new LockRpcToClient(clientconnection).LockReleased(
clientconnection, targetobject);
}
else
{
ILockConsumer requester = (ILockConsumer)lockinfo.Requester;
new LockRpcToServer(null).ReleaseLock(
this, targetobject);
}
RemovedLocks.Add(lockinfo.TargetObject);
}
}
for (int i = 0; i < RemovedLocks.Count; i++)
{
locks.Remove(RemovedLocks[i]);
}
}
// renew lock; no response required; if the lock gets released, we get the response in LockReleased anyway
// client to server
public void RenewLock(object netconnection, NetworkInterfaces.IReplicated targetobject)
{
if (locks.ContainsKey(targetobject) && ((LockInfo)locks[targetobject]).Requester == netconnection)
{
((LockInfo)locks[targetobject]).RenewTimestamp();
}
}
// if this is one of our locks, signal the ILockConsumer, then mark lock released
// server to client
public void LockReleased(object netconnection, NetworkInterfaces.IReplicated targetobject)
{
if (locks.Contains(targetobject))
{
((ILockConsumer)locks[targetobject]).LockReleased(this, new LockReleasedEventArgs(targetobject));
locks.Remove(targetobject);
}
}
public bool MeOwnsLock(NetworkInterfaces.IReplicated requester, NetworkInterfaces.IReplicated targetobject)
{
if (locks[targetobject] != null && ((LockInfo)locks[targetobject]).Requester == requester)
{
return(true);
}
return(false);
}
// runs on master, called by rpc call or non-rpc call
// returns true if lock granted successfully, or already owned by requester
bool _MasterRequestLock(object requester, NetworkInterfaces.IReplicated targetobject)
{
if (!locks.Contains(targetobject))
{
locks.Add(targetobject, new LockInfo(requester, targetobject));
return(true);
}
else if (((LockInfo)locks[targetobject]).Requester == requester)
{
return(true);
}
return(false);
}
// send result to ILockConsumer, and add lock to locks
// server to client
public void LockRequestResponse(object netconnection, NetworkInterfaces.IReplicated targetobject, bool LockCreated)
{
for (int i = 0; i < pendingrpcrequests.Count; i++)
{
object[] pendingrequest = (object[])pendingrpcrequests[i];
if (pendingrequest[1] == targetobject)
{
((ILockConsumer)pendingrequest[0]).LockResponse(this, new LockRequestEventArgs(targetobject, LockCreated));
if (locks.Contains(targetobject))
{
locks.Remove(targetobject);
}
locks.Add(targetobject, new LockInfo(pendingrequest[0], targetobject));
pendingrpcrequests.RemoveAt(i);
i--;
}
}
}
// if we are master, we can grant lock if available, then signal requester immediately
// otherwise we makes async rpc request to server
public void RequestLock(ILockConsumer requester, NetworkInterfaces.IReplicated targetobject)
{
if (ismaster)
{
bool lockgranted = _MasterRequestLock(requester, targetobject);
requester.LockResponse(this, new LockRequestEventArgs(targetobject, lockgranted));
}
else
{
if (((LockInfo)locks[targetobject]).Requester == requester)
{
requester.LockResponse(this, new LockRequestEventArgs(targetobject, true));
}
else if (locks[targetobject] != null)
{
requester.LockResponse(this, new LockRequestEventArgs(targetobject, false));
}
else
{
pendingrpcrequests.Add(new object[] { requester, targetobject });
new LockRpcToServer(null).ReleaseLock(null, targetobject);
}
}
}
public LockInfo(object Requester, NetworkInterfaces.IReplicated TargetObject)
{
this.Requester = Requester; this.TargetObject = TargetObject;
Timestamp = DateTime.Now;
}
public void LockReleased(object netconnection, NetworkInterfaces.IReplicated targetobject)
{
LockController.GetInstance().LockReleased(netconnection, targetobject);
}
public void LockRequestResponse(object netconnection, NetworkInterfaces.IReplicated targetobject, bool LockCreated)
{
LockController.GetInstance().LockRequestResponse(netconnection, targetobject, LockCreated);
}
public void RenewLock(object netconnection, NetworkInterfaces.IReplicated targetobject)
{
LockController.GetInstance().RenewLock(netconnection, targetobject);
}
// client to server
public void ReleaseLock(object netconnection, NetworkInterfaces.IReplicated targetobject)
{
}
// client to server
public void RequestLock(object netconnection, NetworkInterfaces.IReplicated targetobject)
{
bool lockgranted = _MasterRequestLock(netconnection, targetobject);
new LockRpcToClient(netconnection).LockRequestResponse(netconnection, targetobject, lockgranted);
}
public LockInfo(object Requester, NetworkInterfaces.IReplicated TargetObject)
{
this.Requester = Requester; this.TargetObject = TargetObject;
Timestamp = DateTime.Now;
}
