public TimeSpan Renewal(ILease lease) {
#if DEBUG
return TimeSpan.FromMinutes(10);
#else
return TimeSpan.FromHours(1);
#endif
}
// In order to take advantage of the XamlBuildTaskRemotingLeaseLifetimeInMinutes environment variable from an MSBuild
// project file (e.g. csproj file), the following needs to be added to that project file:
//
// After the initial "<Project ..." line:
// <UsingTask TaskName="MySetEnv" TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v4.0.dll" >
// <ParameterGroup>
// <Name Required="true" />
// <Value Required="false" />
// </ParameterGroup>
// <Task>
// <Code Type="Fragment" Language="cs">System.Environment.SetEnvironmentVariable(Name, Value);</Code>
// </Task>
// </UsingTask>
//
// And at the end of the project file, before the closing </Project> :
//
// <Target Name="BeforeBuild">
// <MySetEnv Name="XamlBuildTaskTimeoutInMinutes" Value="24" />
// </Target>
// <Target Name="AfterBuild">
// <MySetEnv Name="XamlBuildTaskRemotingLeaseLifetimeInMinutes" Value="" />
// </Target>
//
// This example uses a task name of "MySetEnv", but it that name could be anything desired.
// It also sets the timeout to 24 minutes, as defined as the Value specified to the MySetEnv task.
// The AfterBuild target is not required, but is probably desired so that the environment variable setting
// does not persist after the processing of this particular project file.
// The valid values for the environment variable are numbers between 1 and 2147483647 inclusive
// (positive 32-bit integers). Any other value will result in no change to the lease lifetime.
internal static void SetLeaseLifetimeFromEnvironmentVariable(ILease lease)
{
// We can only change the lease lifetime if we have an ILease and it is still in the Initial state.
if ((lease != null) && (lease.CurrentState == LeaseState.Initial))
{
try
{
string remotingLeaseLifetimeInMinutesStringValue = Environment.GetEnvironmentVariable(RemotingLeaseLifetimeInMinutesEnvironmentVariableName);
if (!string.IsNullOrEmpty(remotingLeaseLifetimeInMinutesStringValue))
{
int remotingLeaseLifetimeInMinutes = -1;
if (Int32.TryParse(remotingLeaseLifetimeInMinutesStringValue, NumberStyles.Integer, CultureInfo.InvariantCulture, out remotingLeaseLifetimeInMinutes))
{
// revert to the defauilt if the number specified is less than or equal to 0.
if (remotingLeaseLifetimeInMinutes > 0)
{
lease.InitialLeaseTime = TimeSpan.FromMinutes(remotingLeaseLifetimeInMinutes);
lease.RenewOnCallTime = TimeSpan.FromMinutes(remotingLeaseLifetimeInMinutes);
}
}
}
}
catch (Exception ex)
{
// simply ignore any exceptions that might have occurred and go with the default. We can't log it because
// we aren't initialized enough at this point.
if (Fx.IsFatal(ex))
{
throw;
}
}
}
}
public TimeSpan Renewal(ILease lease)
{
//If the kill delay has expired
if (m_expireSet && m_expires.CompareTo(DateTime.Now) < 0)
m_live = false;
return m_live ? TimeSpan.FromMinutes(TIMEOUT_MIN) : TimeSpan.Zero;
}
public LeaseAcquireResponse TryRenewBrokerLease(String topic, int partition, ILease lease, String sessionId,
int brokerPort)
{
long expireTime = new DateTime().CurrentTimeMillis() + 10 * 1000L;
long leaseId = m_leaseId.AtomicIncrementAndGet();
return new LeaseAcquireResponse(true, new DefaultLease(leaseId, expireTime), expireTime);
}
TimeSpan ISponsor.Renewal(ILease lease)
{
if (lease == null)
{
throw new ArgumentNullException("lease");
}
return _timespan;
}
public CacheLifecycle(ILease lease)
{
if (lease == null)
{
throw new ArgumentNullException("lease");
}
this.cache = new LeasedObjectCache(lease);
}
public CacheLifetimeManager(ILease lease)
{
if (lease == null)
{
throw new ArgumentNullException("lease");
}
this.lease = lease;
}
private async Task <DocumentServiceLease> TryGetLeaseAsync(ILease lease)
{
Uri documentUri = this.CreateDocumentUri(lease.Id);
Document document = await this.client.TryGetDocumentAsync(
documentUri,
this.requestOptionsFactory.CreateRequestOptions(lease))
.ConfigureAwait(false);
return(document != null?DocumentServiceLease.FromDocument(document) : null);
}
public override object InitializeLifetimeService()
{
ILease lease = (ILease)base.InitializeLifetimeService();
if (lease.CurrentState == LeaseState.Initial)
{
lease.InitialLeaseTime = TimeSpan.FromSeconds(30.0);
}
return(lease);
}
/// <summary>
/// Verifies that a lease is registered/unregistered for the lifetime service.
/// </summary>
/// <param name="lease">The lease that is checked.</param>
/// <param name="checkRegistered">if set to <c>true</c> it is checked that it is registered otherwise
/// it must be unregistered.</param>
private void VerifyLifetimeServiceRegistered(ILease lease, bool checkRegistered)
{
Hashtable sponsorTable = (Hashtable)lease.GetType()
.GetField("sponsorTable", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(lease);
string message = checkRegistered
? "Expected lifetime service to be registered."
: "Expected lifetime service to be unregistered.";
Assert.AreEqual(checkRegistered, sponsorTable.Contains(this.asyncResult), message);
}
private void SetupReplaceConflict(IChangeFeedDocumentClient client, ILease updatedLease)
{
Mock.Get(client)
.Setup(c => c.ReplaceDocumentAsync(
documentUri,
updatedLease,
It.Is <RequestOptions>(options => options.AccessCondition.Type == AccessConditionType.IfMatch && options.AccessCondition.Condition == eTag1),
default(CancellationToken)))
.ThrowsAsync(DocumentExceptionHelpers.CreatePreconditionFailedException());
}
/// <summary>
/// Obtains a lifetime service object to control the lifetime policy for this instance.
/// </summary>
/// <returns>An object of type ILease used to control the lifetime
/// policy for this instance.</returns>
public override object InitializeLifetimeService()
{
ILease lease = (ILease)base.InitializeLifetimeService();
if (lease != null)
{
lease.Register(_sponsor);
}
return(lease);
}
private RequestOptions CreateIfMatchOptions(ILease lease)
{
var ifMatchCondition = new AccessCondition {
Type = AccessConditionType.IfMatch, Condition = lease.ConcurrencyToken
};
return(new RequestOptions {
AccessCondition = ifMatchCondition
});
}
/// <summary>
/// Prepare the lease sponsorship settings
/// </summary>
/// <returns></returns>
public override object InitializeLifetimeService()
{
ILease LeaseInfo = (ILease)base.InitializeLifetimeService();
LeaseInfo.InitialLeaseTime = TimeSpan.FromMinutes(GPEnums.REMOTING_RENEWAL_MINUTES);
LeaseInfo.RenewOnCallTime = TimeSpan.FromMinutes(GPEnums.REMOTING_RENEWAL_MINUTES);
LeaseInfo.SponsorshipTimeout = TimeSpan.FromMinutes(GPEnums.REMOTING_TIMEOUT_MINUTES);
return(LeaseInfo);
}
override public object InitializeLifetimeService()
{
ILease iLease = (ILease)base.InitializeLifetimeService();
iLease.InitialLeaseTime = TimeSpan.FromSeconds(20);
iLease.SponsorshipTimeout = TimeSpan.FromSeconds(20);
iLease.RenewOnCallTime = TimeSpan.FromSeconds(20);
iLease.Register(this);
return(iLease);
}
public override object InitializeLifetimeService()
{
ILease lease = (ILease)base.InitializeLifetimeService();
lease.InitialLeaseTime = DefaultLease.InitialLeaseTime;
lease.RenewOnCallTime = DefaultLease.RenewOnCallTime;
lease.SponsorshipTimeout = DefaultLease.SponsorshipTimeout;
return(lease);
//return null;
}
/// <summary>
/// Obtains a lifetime service object to control the lifetime policy for
/// this instance.
/// </summary>
/// <returns>
/// An object of type <see cref="ILease" /> used to control the lifetime
/// policy for this instance. This is the current lifetime service object
/// for this instance if one exists; otherwise, a new lifetime service
/// object initialized with a lease that will never time out.
/// </returns>
public override Object InitializeLifetimeService()
{
ILease lease = (ILease)base.InitializeLifetimeService();
if (lease.CurrentState == LeaseState.Initial)
{
lease.InitialLeaseTime = TimeSpan.Zero;
}
return(lease);
}
public override object InitializeLifetimeService()
{
// We want an infinite lifetime as far as the
// remoting infrastructure is concerned
// (Thanks for Mike Woodring for pointing this out)
ILease lease = (ILease)base.InitializeLifetimeService();
lease.InitialLeaseTime = TimeSpan.Zero;
return(lease);
}
/// <summary>Empties the list objects registered with the current <see cref="T:System.Runtime.Remoting.Lifetime.ClientSponsor" />.</summary>
/// <PermissionSet>
/// <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="Infrastructure" />
/// </PermissionSet>
public void Close()
{
foreach (object obj in this.registered_objects.Values)
{
MarshalByRefObject marshalByRefObject = (MarshalByRefObject)obj;
ILease lease = marshalByRefObject.GetLifetimeService() as ILease;
lease.Unregister(this);
}
this.registered_objects.Clear();
}
/// <summary>
/// Initializes a new instance of the <see cref="RemoteClient"/> class.
/// </summary>
public RemoteClient()
{
clientchannel = new IpcChannel();
ChannelServices.RegisterChannel(clientchannel, false);
RemotingConfiguration.RegisterWellKnownClientType(typeof(RemoteObject), "ipc://localhost:15000/RemoteObject.rem");
RemoteObj = new RemoteObject();
sponser = new RemoteClientSponser("RemoteClient");
lease = (ILease)RemoteObj.GetLifetimeService();
lease.Register(sponser);
}
public Sponsor(T obj)
{
mObj = obj;
// Get the lifetime service lease from the MarshalByRefObject,
// and register ourselves as a sponsor.
ILease lease = (ILease)obj.GetLifetimeService();
lease.Register(this);
}
public LeasedObjectCache(ILease lease)
{
if (lease == null)
{
throw new ArgumentNullException("lease");
}
this.lease = lease;
this.objectCache = new LifecycleObjectCache();
}
public LeasedObjectCache(ILease lease)
{
if (lease == null)
{
throw new ArgumentNullException("lease");
}
this.lease = lease;
this.objectCache = new MainObjectCache();
}
private void RenewLease(IMessage msg)
{
ServerIdentity serverIdentity = (ServerIdentity)RemotingServices.GetMessageTargetIdentity(msg);
ILease lease = serverIdentity.Lease;
if (lease != null && lease.CurrentLeaseTime < lease.RenewOnCallTime)
{
lease.Renew(lease.RenewOnCallTime);
}
}
public Request(Host host, Connection connection)
: base(string.Empty, string.Empty, null)
{
this._host = host;
this._connection = connection;
ILease lease = (ILease)RemotingServices.GetLifetimeService(this._connection);
this._connectionSponsor = new Sponsor();
lease.Register(this._connectionSponsor);
}
public override object InitializeLifetimeService()
{
ILease lease = (ILease)base.InitializeLifetimeService();
//Set lease properties
lease.InitialLeaseTime = TimeSpan.FromSeconds(5);
lease.RenewOnCallTime = TimeSpan.FromSeconds(3);
lease.SponsorshipTimeout = TimeSpan.FromSeconds(10);
return(lease);
}
public TimeSpan Renewal(ILease lease)
{
Console.WriteLine("{0}: Sponsor chamado",DateTime.Now);
if (IsForRenew) {
Console.WriteLine("{0}: vai renovar 10 seg.",DateTime.Now);
return TimeSpan.FromSeconds(10);
} else {
Console.WriteLine("{0}: Não renova mais.",DateTime.Now);
return TimeSpan.Zero;
}
}
public override object InitializeLifetimeService()
{
TianTiService.Instance = this;
ILease lease = (ILease)base.InitializeLifetimeService();
if (lease.CurrentState == LeaseState.Initial)
{
lease.InitialLeaseTime = TimeSpan.FromDays(2000.0);
}
return(lease);
}
// Note: requestOptions are only used for read and not for update.
public async Task <ILease> UpdateLeaseAsync(
ILease cachedLease,
Uri documentUri,
RequestOptions requestOptions,
Func <ILease, ILease> updateLease,
bool retryOnConflict)
{
ILease lease = cachedLease;
for (int retryCount = retryOnConflict ? RetryCountOnConflict : 0; retryCount >= 0; retryCount--)
{
lease = updateLease(lease);
if (lease == null)
{
return(null);
}
lease.Timestamp = DateTime.UtcNow;
Document leaseDocument = await this.TryReplaceLeaseAsync(lease, documentUri).ConfigureAwait(false);
if (leaseDocument != null)
{
return(DocumentServiceLease.FromDocument(leaseDocument));
}
Logger.InfoFormat("Partition {0} lease update conflict. Reading the current version of lease.", lease.PartitionId);
Document document;
try
{
IResourceResponse <Document> response = await this.client.ReadDocumentAsync(
documentUri, requestOptions).ConfigureAwait(false);
document = response.Resource;
}
catch (DocumentClientException ex) when(ex.StatusCode == HttpStatusCode.NotFound)
{
Logger.InfoFormat("Partition {0} lease no longer exists", lease.PartitionId);
throw new LeaseLostException(lease);
}
DocumentServiceLease serverLease = DocumentServiceLease.FromDocument(document);
Logger.InfoFormat(
"Partition {0} update failed because the lease with token '{1}' was updated by host '{2}' with token '{3}'. Will retry, {4} retry(s) left.",
lease.PartitionId,
lease.ConcurrencyToken,
serverLease.Owner,
serverLease.ConcurrencyToken,
retryCount);
lease = serverLease;
}
throw new LeaseLostException(lease);
}
///////////////////////////////////////////////////////////////////////
public override Object InitializeLifetimeService()
{
// We don't ever want this to expire...
ILease NewLease = ( ILease )base.InitializeLifetimeService();
if (NewLease.CurrentState == LeaseState.Initial)
{
NewLease.InitialLeaseTime = TimeSpan.Zero;
}
return(NewLease);
}
public void Unregister(MarshalByRefObject obj)
{
if (!registered_objects.ContainsKey(obj))
{
return;
}
ILease lease = obj.GetLifetimeService() as ILease;
lease.Unregister(this);
registered_objects.Remove(obj);
}
public override object InitializeLifetimeService()
{
ILease tmp = (ILease)base.InitializeLifetimeService();
if (tmp.CurrentState == LeaseState.Initial)
{
tmp.InitialLeaseTime = TimeSpan.FromSeconds(5);
tmp.RenewOnCallTime = TimeSpan.FromSeconds(1);
}
return(tmp);
}
/// <summary>
/// Closes the connection.
/// </summary>
private void CloseConnectionInternal()
{
if (this._connection != null)
{
this._connection.Close();
ILease lease = (ILease)RemotingServices.GetLifetimeService(this._connection);
lease.Unregister(this._connectionSponsor);
this._connection = null;
this._connectionSponsor = null;
}
}
/// <inheritdoc />
/// <summary>
/// InitializeLifetimeService is called when the remote object is activated.
/// This method will determine how long the lifetime for the object will be.
/// </summary>
/// <returns>The lease object to control this object's lifetime.</returns>
public override object InitializeLifetimeService()
{
lock (_callbackMonitor)
{
VerifyActiveProxy();
// Each MarshalByRef object has a reference to the service which
// controls how long the remote object will stay around
ILease lease = (ILease)base.InitializeLifetimeService();
// Set how long a lease should be initially. Once a lease expires
// the remote object will be disconnected and it will be marked as being availiable
// for garbage collection
int initialLeaseTime = 1;
string initialLeaseTimeFromEnvironment = Environment.GetEnvironmentVariable("MSBUILDENGINEPROXYINITIALLEASETIME");
if (!String.IsNullOrEmpty(initialLeaseTimeFromEnvironment))
{
int leaseTimeFromEnvironment;
if (int.TryParse(initialLeaseTimeFromEnvironment, out leaseTimeFromEnvironment) && leaseTimeFromEnvironment > 0)
{
initialLeaseTime = leaseTimeFromEnvironment;
}
}
lease.InitialLeaseTime = TimeSpan.FromMinutes(initialLeaseTime);
// Make a new client sponsor. A client sponsor is a class
// which will respond to a lease renewal request and will
// increase the lease time allowing the object to stay in memory
_sponsor = new ClientSponsor();
// When a new lease is requested lets make it last 1 minutes longer.
int leaseExtensionTime = 1;
string leaseExtensionTimeFromEnvironment = Environment.GetEnvironmentVariable("MSBUILDENGINEPROXYLEASEEXTENSIONTIME");
if (!String.IsNullOrEmpty(leaseExtensionTimeFromEnvironment))
{
int leaseExtensionFromEnvironment;
if (int.TryParse(leaseExtensionTimeFromEnvironment, out leaseExtensionFromEnvironment) && leaseExtensionFromEnvironment > 0)
{
leaseExtensionTime = leaseExtensionFromEnvironment;
}
}
_sponsor.RenewalTime = TimeSpan.FromMinutes(leaseExtensionTime);
// Register the sponsor which will increase lease timeouts when the lease expires
lease.Register(_sponsor);
return(lease);
}
}
/// <summary>
/// Renews the lease on the instance as though it has been called normally.
/// </summary>
/// <param name="lease"></param>
/// <returns></returns>
TimeSpan ISponsor.Renewal(ILease lease)
{
if (IsDisposed)
{
return(TimeSpan.Zero);
}
else
{
return(LifetimeServices.RenewOnCallTime);
}
}
internal static ILease GetLeaseInitial(MarshalByRefObject obj)
{
LeaseManager leaseManager = LeaseManager.GetLeaseManager(LifetimeServices.LeaseManagerPollTime);
ILease lease = leaseManager.GetLease(obj);
if (lease == null)
{
lease = LifetimeServices.CreateLease(obj);
}
return(lease);
}
public override object InitializeLifetimeService()
{
//Default lease associated with remote object is retrieved
ILease objLease = (ILease)base.InitializeLifetimeService();
//Initial Lease time is updated to 3 minute
objLease.InitialLeaseTime = TimeSpan.FromMinutes(3);
//Renewal time is updated to 1 minute
objLease.RenewOnCallTime = TimeSpan.FromMinutes(1);
return(objLease);
}
private IDocumentServiceLeaseUpdater CreateLeaseUpdater(ILease expectedCachedLease)
{
var leaseUpdater = Mock.Of <IDocumentServiceLeaseUpdater>();
MockLease storedLease = CreateStoredLease(owner);
Mock.Get(leaseUpdater)
.Setup(u => u.UpdateLeaseAsync(expectedCachedLease, documentUri, It.IsAny <Func <ILease, ILease> >()))
.Callback((ILease cachedLease, Uri uri, Func <ILease, ILease> callback) => callback(storedLease))
.ReturnsAsync(storedLease);
return(leaseUpdater);
}
public override object InitializeLifetimeService()
{
ILease lease = (ILease)base.InitializeLifetimeService();
Debug.Assert(lease.CurrentState == LeaseState.Initial);
//Set lease properties
lease.InitialLeaseTime = TimeSpan.FromMinutes(30);
lease.RenewOnCallTime = TimeSpan.FromMinutes(10);
lease.SponsorshipTimeout = TimeSpan.FromMinutes(2);
return(lease);
}
public TimeSpan Renewal(ILease lease)
{
if (!this.disposed)
{
return(TimeSpan.FromSeconds(30));
}
else
{
throw new InvalidOperationException();
}
}
public TimeSpan Renewal(ILease lease)
{
if (discovery.GetPeers().Count != 0)
{
Debug.WriteLine("! PeerDiscoverySponsor.Renewal() Peers != 0");
return TimeSpan.FromSeconds(2);
}
Debug.WriteLine("! PeerDiscoverySponsor.Renewal() Peers is 0");
discovery.Dispose();
discovery = null;
return TimeSpan.Zero;
}
public virtual void Start(StartOptions options)
{
var context = new StartContext(options);
IServiceProvider services = ServicesFactory.Create(context.Options.Settings);
var engine = services.GetService<IHostingEngine>();
_runningApp = engine.Start(context);
_lease = (ILease)RemotingServices.GetLifetimeService(this);
_lease.Register(this);
}
public void StartTrackingLifetime (ILease lease)
{
// Adds this identity to the LeaseManager.
// _serverObject must be set.
if (lease != null && lease.CurrentState == LeaseState.Null) lease = null;
if (lease != null)
{
if (! (lease is Lease)) lease = new Lease(); // This seems to be MS behavior
_lease = (Lease) lease;
LifetimeServices.TrackLifetime (this);
}
}
public LeaseAcquireResponse TryRenewConsumerLease(Tpg tpg, ILease lease, String sessionId)
{
Dictionary<string, string> p = new Dictionary<string, string>();
p.Add(LEASE_ID, Convert.ToString(lease.ID));
p.Add(SESSION_ID, sessionId);
p.Add(HOST, Local.IPV4);
String response = Post("/lease/consumer/renew", p, tpg);
if (response != null)
{
return JSON.DeserializeObject<LeaseAcquireResponse>(response);
}
else
{
return null;
}
}
public override ILeaseHandle[] Acquire(object[] keys, int millis, WaitCallback expiryCallback)
{
lock (_Sync)
{
int count = keys.Length;
var leases = new ILease[count];
var expired = new int[count];
var create = new int[count];
int e = 0; // index for expired[]
int c = 0; // index for create[]
ILease lease;
int threadID = Thread.CurrentThread.ManagedThreadId;
for (int i = 0; i < keys.Length; i++)
{
object key = keys[i];
if (_Leases.TryGetValue(key, out lease))
{
leases[i] = lease;
if (lease.Expired) expired[e++] = i;
else if (lease.ThreadID != threadID) return null;
}
else
{
create[c++] = i;
}
}
for (int i = 0; i < e; i++)
{
int k = expired[i];
lease = leases[k];
Free(lease);
if (lease.ExpiryCallback != null) ThreadPool.QueueUserWorkItem(lease.ExpiryCallback, lease);
leases[k] = Add(keys[k], millis, expiryCallback);
}
for (int i = 0; i < c; i++)
{
int k = create[i];
leases[k] = Add(keys[k], millis, expiryCallback);
}
return leases;
}
}
public TimeSpan Renewal(ILease lease)
{
do
{
try
{
Console.WriteLine("{0}: MainSponsor.Renewal()", _myRegSponsor.GetId());
return _listSponsors[0].Renewal(lease);
}
catch (Exception)
{
Console.WriteLine("##### {0}: Client Disconnected", _myRegSponsor.GetId());
_listSponsors.RemoveAt(0);
if (_listSponsors.Count == 0)
_myRegSponsor.Dispose();
}
} while (_listSponsors.Count > 0);
return TimeSpan.FromSeconds(0);
}
public TimeSpan Renewal(ILease lease)
{
Predicate<KeyValuePair<ILease, WeakReference>> match = null;
OneWayList<KeyValuePair<ILease, WeakReference>> list;
WeakReference reference = null;
lock ((list = this.LeaseObjectList))
{
foreach (KeyValuePair<ILease, WeakReference> pair in this.LeaseObjectList)
{
if (object.ReferenceEquals(pair.Key, lease))
{
reference = pair.Value;
goto Label_0090;
}
}
}
Label_0090:
if (reference != null)
{
if (reference.IsAlive && (reference.Target != null))
{
lease.Renew(this.RenewalTime);
return this.RenewalTime;
}
lock ((list = this.LeaseObjectList))
{
if (match == null)
{
match = delegate (KeyValuePair<ILease, WeakReference> x) {
return object.ReferenceEquals(x.Key, lease) || !x.Value.IsAlive;
};
}
this.LeaseObjectList.RemoveAll(match);
}
}
return TimeSpan.Zero;
}
// Request renewal of a lease.
public TimeSpan Renewal(ILease lease)
{
return renewalTime;
}
public TimeSpan Renewal(ILease lease)
{
Console.WriteLine("{0}: Renewing lease for more {1}", DateTime.Now, m_renewLeaseTime);
return TimeSpan.FromSeconds(m_renewLeaseTime);
}
// In theory: I execute, therefore I am.
// If GC collects this class then sponsorship will expire
public TimeSpan Renewal(ILease lease)
{
return TimeSpan.FromMinutes(2);
}
public TimeSpan Renewal(ILease leaseInfo)
{
Console.WriteLine("{0}: SingletonClientSponsor.Renewal()", _name);
return TimeSpan.FromSeconds(4);
}
public virtual System.TimeSpan Renewal(ILease lease) {}
public TimeSpan Renewal(ILease lease)
{
if (!m_closed)
return lease.InitialLeaseTime;
return TimeSpan.FromTicks(0);
}
public TimeSpan Renewal(ILease lease)
{
TimeSpan tsLease = TimeSpan.FromMinutes(5);
lease.Renew(tsLease);
return tsLease;
}
public LeaseAcquireResponse TryRenewConsumerLease(Tpg tpg, ILease lease, String sessionId)
{
return new LeaseAcquireResponse(false, null, new DateTime().CurrentTimeMillis() + 10 * 1000L);
}
/// <summary>
/// Verifies that a lease is registered/unregistered for the lifetime service.
/// </summary>
/// <param name="lease">The lease that is checked.</param>
/// <param name="checkRegistered">if set to <c>true</c> it is checked that it is registered otherwise
/// it must be unregistered.</param>
private void VerifyLifetimeServiceRegistered(ILease lease, bool checkRegistered)
{
Hashtable sponsorTable = (Hashtable)lease.GetType()
.GetField("sponsorTable", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(lease);
string message = checkRegistered
? "Expected lifetime service to be registered."
: "Expected lifetime service to be unregistered.";
Assert.AreEqual(checkRegistered, sponsorTable.Contains(this.asyncResult), message);
}
public TimeSpan Renewal(ILease lease)
{
return new TimeSpan(0, 1, 0, 0);
}
//[SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure)]
public TimeSpan Renewal(ILease lease)
{
(new Logger()).WriteDebug4("lease:renewal:" + (null == _cAtom ? "no" : "yes:" + _cAtom.GetHashCode()));
if(null != _cAtom)
return TimeSpan.FromSeconds(20);
return TimeSpan.Zero;
}
public TimeSpan Renewal(ILease lease)
{
BCLDebug.Trace("REMOTE", "ClientSponsor Renewal "+m_renewalTime);
return m_renewalTime;
}
public TimeSpan Renewal (ILease lease)
{
return TimeSpan.FromSeconds (7);
}
