/// <inheritdoc cref="Application.Excel.TextBox"/>
internal void TextBox(
int row, int column, ISessionObject sessionObject, RoleType roleType, RoleType relationType = null,
RoleType displayRoleType = null,
string numberFormat = null,
Func <object, dynamic> toDomain = null,
Func <ISessionObject, dynamic> toCell = null,
Func <ICell, ISessionObject> factory = null)
{
if (sessionObject != null || factory != null)
{
var cell = this.Worksheet[row, column];
cell.NumberFormat = numberFormat;
if (!this.ControlByCell.TryGetValue(cell, out var control))
{
control = new TextBox(cell);
this.ControlByCell.TryAdd(cell, control);
}
var textBox = (TextBox)control;
textBox.SessionObject = sessionObject;
textBox.RoleType = roleType;
textBox.RelationType = relationType;
textBox.DisplayRoleType = displayRoleType;
textBox.ToDomain = toDomain;
textBox.ToCell = toCell;
textBox.Factory = factory;
this.ActiveControls.Add(control);
}
}
internal ICell Select(int row, int column, Range options, ISessionObject sessionObject, RoleType roleType, RoleType relationType = null,
RoleType displayRoleType = null,
Func <object, dynamic> getRelation = null,
string numberFormat = null,
bool hideInCellDropDown = false)
{
ICell cell = null;
if (sessionObject != null)
{
cell = this.Worksheet[row, column];
cell.Options = options ?? throw new ArgumentNullException(nameof(options));
cell.NumberFormat = numberFormat;
cell.HideInCellDropdown = hideInCellDropDown;
cell.IsRequired = roleType.IsRequired;
if (!this.ControlByCell.TryGetValue(cell, out var control))
{
control = new ComboBox(cell);
this.ControlByCell.TryAdd(cell, control);
}
var comboBox = (ComboBox)control;
comboBox.SessionObject = sessionObject;
comboBox.RoleType = roleType;
comboBox.RelationType = relationType;
comboBox.DisplayRoleType = displayRoleType;
comboBox.ToDomain = getRelation;
this.ActiveControls.Add(control);
}
return(cell);
}
public RoleTypeBinding(ISessionObject @object, RoleType roleType, RoleType relationType = null, bool oneWayBinding = false)
{
this.Object = @object;
this.RoleType = roleType;
this.RelationType = relationType;
this.OneWayBinding = oneWayBinding;
}
/// <summary>
/// Adds a session into the dictionary
/// </summary>
/// <param name="Key">Session Key</param>
/// <param name="Session">Session object</param>
/// <param name="UpdateIfNotFound">Indicates whether session should be updated if the session was not found. If set to flase, this gives the caller a chance to query the network before trying again</param>
/// <param name="LockedSessionInfo">Locked session information if session is locked</param>
/// <returns>Result of Action</returns>
public SessionActionResult Add(string Key, ISessionObject Session, bool UpdateIfNotFound, out SessionResponseInfo LockedSessionInfo)
{
//If an item with key already exists, return SessionActionResult.AlreadyExists
//else add the item and return SessionActionResult.OK
//Calls UpSert internally
return(UpSert(Key, Session, true, UpdateIfNotFound, out LockedSessionInfo)); //Insert Item if it doesn't exist
}
/// <summary>
/// Updates a session (adds a new one if it was not found)
/// </summary>
/// <param name="Key">Session Key</param>
/// <param name="Session">Session object</param>
/// <param name="UpdateIfNotFound">Indicates whether session should be updated if the session was not found. If set to flase, this gives the caller a chance to query the network before trying again</param>
/// <param name="LockedSessionInfo">Locked session information if session is locked</param>
/// <returns>Result of Action</returns>
public SessionActionResult Update(string Key, ISessionObject Session, bool UpdateIfNotFound, out SessionResponseInfo LockedSessionInfo)
{
//If the item is locked and the new items lockCookie does not match, return SessionActionResult.Locked
//else add the item and return SessionActionResult.OK
//Calls UpSert internally
return(UpSert(Key, Session, false, UpdateIfNotFound, out LockedSessionInfo)); //Insert or Update item
}
public void OnChanged(object checkedValue, ISessionObject option)
{
if ((bool)checkedValue)
{
this.Object.Add(this.RoleType, option);
}
else
{
this.Object.Remove(this.RoleType, option);
}
}
public static IntPtr GetHandle(this ISessionObject sessionObject)
{
INativeObject nativeObject = sessionObject as INativeObject;
if (nativeObject != null)
{
return(nativeObject.Handle);
}
return(IntPtr.Zero);
}
public void Remove(RoleType roleType, ISessionObject value)
{
var roles = (ISessionObject[])this.Get(roleType);
if (roles.Contains(value))
{
var newRoles = new List <ISessionObject>(roles);
newRoles.Remove(value);
roles = newRoles.ToArray();
}
this.Set(roleType, roles);
}
private void SetCellValue(ISessionObject obj, RoleType roleType)
{
if (roleType.ObjectType.ClrType == typeof(bool))
{
if (obj.Get(roleType) is bool boolvalue && boolvalue)
{
this.Cell.Value = Constants.YES;
}
else
{
this.Cell.Value = Constants.NO;
}
}
public void TextBox(ISessionObject sessionObject, RoleType roleType)
{
var key = $"{sessionObject?.Id}:{roleType?.Id}";
if (!this.Members.TryGetValue(key, out var control))
{
var textBox = new TextBox(this.Cell);
textBox.SessionObject = sessionObject;
textBox.RoleType = roleType;
this.Members.Add(key, textBox);
}
}
/// <summary>
/// Copies all data from one Session object to this one
/// </summary>
/// <param name="ObjectToCopy">Session object to copy from</param>
public void CopyFrom(ISessionObject ObjectToCopy)
{
//Do not copy inUse and isExporting properties (they are used internally)
//inuse = ObjectToCopy.IsInUse ? -1 : 0;
//isExporting = ObjectToCopy.IsExporting;
data = ObjectToCopy.Data;
lockCookie = ObjectToCopy.LockCookie;
lockDate = ObjectToCopy.LockDate;
updateDate = ObjectToCopy.UpdateDate;
timeout = ObjectToCopy.TimeOut;
extraFlags = (sbyte)ObjectToCopy.ExtraFlags;
locked = ObjectToCopy.IsLocked;
}
public void Add(RoleType roleType, ISessionObject value)
{
var roles = (ISessionObject[])this.Get(roleType);
if (!roles.Contains(value))
{
roles = new List <ISessionObject>(roles)
{
value
}.ToArray();
}
this.Set(roleType, roles);
}
/// <summary>
/// Gets the session object.
/// </summary>
/// <returns></returns>
public static ISessionObject GetSessionObject()
{
ISessionObject property = null;
IObjectContext context;
if (CoGetObjectContext(ref IID_IObjectContext, out context) == 0)
{
IGetContextProperties o = (IGetContextProperties)context;
if (o != null)
{
property = (ISessionObject)o.GetProperty("Session");
Marshal.ReleaseComObject(o);
}
Marshal.ReleaseComObject(context);
}
return(property);
}
public static ISessionObject GetSessionObject()
{
ISessionObject session = null;
IObjectContext obj;
if (0 == NativeMethods.CoGetObjectContext(ref IID_IObjectContext, out obj))
{
IGetContextProperties prop = (IGetContextProperties)obj;
if (prop != null)
{
session = (ISessionObject)prop.GetProperty("Session");
Marshal.ReleaseComObject(prop);
}
Marshal.ReleaseComObject(obj);
}
return(session);
}
/// <summary>
/// Sets a readonly value in the cell. Changes are not handled.
/// </summary>
/// <param name="cell"></param>
/// <param name="sessionObject"></param>
/// <param name="roleType"></param>
/// <param name="relationType"></param>
internal void Label(int row, int column, ISessionObject sessionObject, RoleType roleType, RoleType relationType = null, string numberFormat = null)
{
if (sessionObject != null)
{
var cell = this.Worksheet[row, column];
cell.NumberFormat = numberFormat;
if (!this.ControlByCell.TryGetValue(cell, out var control))
{
control = new Label(cell);
this.ControlByCell.TryAdd(cell, control);
}
var label = (Label)control;
label.SessionObject = sessionObject;
label.RoleType = roleType;
label.RelationType = relationType;
this.ActiveControls.Add(control);
}
}
public void Set(RoleType roleType, object value)
{
if (this.changedRoleByRoleType == null)
{
this.changedRoleByRoleType = new Dictionary <RoleType, object>();
}
if (value == null)
{
if (roleType.ObjectType.IsComposite && roleType.IsMany)
{
value = new ISessionObject[0];
}
}
if (roleType.ObjectType.IsComposite && roleType.IsMany)
{
value = new ArrayList((Array)value).ToArray(roleType.ObjectType.ClrType);
}
this.roleByRoleType[roleType] = value;
this.changedRoleByRoleType[roleType] = value;
}
static public void LogSessionExporting(string key, ISessionObject Session)
{
Debug.WriteLine("[" + GetFormattedTime(DateTime.Now) + "] " + string.Format("Export started for session key {0}, length: {1} bytes \n", key, Session.Data.Length), "SESSION_DICT");
}
public static void LogSessionExporting(string key, ISessionObject Session)
{
Debug.WriteLine( "[" + GetFormattedTime(DateTime.Now) + "] " + string.Format("Export started for session key {0}, length: {1} bytes \n", key, Session.Data.Length), "SESSION_DICT");
}
/// <summary>
/// Called by the SessionDictionary.Read method to complete processing the request,
/// if the requested session was found and read
/// </summary>
/// <param name="Session">The read session object</param>
/// <param name="StateObject">The state object passed from the SessionDictionary.Read method</param>
private void CompleteReadRequest(ISessionObject Session, object StateObject)
{
ServiceMessage msg = (ServiceMessage)StateObject;
if (Session.IsLocked)
{
Reply(BuildResponse(typeof(LockedResponse), null, Session.CreateResponseInfo(), null));
return;
}
else
{
Reply( BuildResponse(typeof(OKResponse), null, Session.CreateResponseInfo(), Session.Data));
if (Session.ExtraFlags != -1) Session.ExtraFlags = -1; //Disable extraflags
}
}
static public void LogUpdatedSession(string key, ISessionObject Session)
{
Debug.WriteLine("[" + GetFormattedTime(DateTime.Now) + "] " + string.Format("Updated session data for key {0} , length: {1} bytes \n", key, Session.Data.Length), "SESSION_DICT");
}
public object ToExcel(ISessionObject sessionObject, RoleType roleType)
{
var bl = (bool?)sessionObject.Get(roleType);
return(bl == true ? "YES" : "NO");
}
public object IsSelected(ISessionObject option)
{
var model = (IEnumerable <ISessionObject>) this.Model;
return(model.Contains(option));
}
public bool IsAttributeSet(ISessionObject session, string attributeName)
{
var strValue = GetAttributeValue(attributeName);
return !string.IsNullOrEmpty(strValue) && strValue != ("#" + session.Session.SessionKey);
}
/// <summary>
/// Called by the SessionDictionary.Read() method to complete processing the request,
/// if the requested session was found and read
/// </summary>
/// <param name="Session">The read session object</param>
/// <param name="StateObject">The state object passed from the SessionDictionary.Read() method</param>
private void CompleteResetTimeoutRequest(ISessionObject Session, object StateObject)
{
ServiceMessage msg = (ServiceMessage)StateObject;
Session.ResetTimeout();
Reply(BuildResponse(typeof(OKResponse), null, Session.CreateResponseInfo(), null));
}
public bool IsAttributeSet(ISessionObject session, string attributeName)
{
var strValue = GetAttributeValue(attributeName);
return(!string.IsNullOrEmpty(strValue) && strValue != ("#" + session.Session.SessionKey));
}
public static void LogUpdatedSession(string key, ISessionObject Session)
{
Debug.WriteLine( "[" + GetFormattedTime(DateTime.Now) + "] " + string.Format("Updated session data for key {0} , length: {1} bytes \n", key, Session.Data.Length), "SESSION_DICT");
}
/// <summary>
/// Removes a session from the dictionary
/// </summary>
/// <param name="Key">Session Key</param>
/// <param name="LockCookie">Lock Cookie</param>
/// <param name="IsExpiring">Indicates that the item is being removed because it's expiring</param>
/// <param name="ExpiryDate">The Item expiry date (for comparison)</param>
/// <param name="LockedSessionInfo">Locked session information if session is locked</param>
/// <returns>Result of Action</returns>
private SessionActionResult Remove(string Key, uint LockCookie, bool IsExpiring, DateTime ExpiryDate, out SessionResponseInfo LockedSessionInfo)
{
if (Key == null)
{
throw new ArgumentNullException("Key");
}
LockedSessionInfo = null;
bool tryAgain;
Diags.ResetDeadLockCounter();
do
{
tryAgain = false;
AcquireReadLock();
ISessionObject entry;
try
{
dict.TryGetValue(Key, out entry);
}
finally
{
ReleaseReadLock();
}
if (entry == null)
{
//Session not found
Diags.LogSessionNotFound(Key);
return(SessionActionResult.NotFound);
}
else
{
//Session Found
if (entry.CompareExchangeIsInUse(true, false) == false)
{
try
{
//The InUse flag is set and so this code section has exclusive access to this session object
AcquireWriteLock();
try
{
//Check again to be sure, now that the write-lock has been obtained
ISessionObject oldEntry = entry;
if (!dict.TryGetValue(Key, out entry))
{
//ooops -- another thread deleted the session from the dictionary while this thread
//was either trying to do the compareExchange (or if buggy, while obtaining the write-lock)
//so try again
oldEntry.CompareExchangeIsInUse(false, true); //unlock the previously locked item
tryAgain = true;
continue;
}
if (IsExpiring)
{
DateTime timeStamp;
if (expiryList.TryGetTimeStamp(Key, out timeStamp))
{
if (timeStamp != ExpiryDate)
{
//The expiration date on this session was updated, so leave
return(SessionActionResult.OK);
}
}
}
if (!IsExpiring && entry.IsLocked) //Locked items DO expire. if not expiring, LockCookie has to match session's
{
if (!entry.UnLock(LockCookie))
{
//Lockcookie did not match
LockedSessionInfo = (SessionResponseInfo)entry.CreateResponseInfo();
Diags.LogSessionIsLocked(Key);
return(SessionActionResult.Locked);
}
}
if (dict.Remove(Key))
{
expiryList.Remove(Key);
if (IsExpiring)
{
Diags.LogSessionExpired(Key);
}
else
{
Diags.LogSessionDeleted(Key);
}
}
else
{
//This should never happen
Diags.Fail("ASSERTION Failed -- Session dictionary was unable to remove key\r\n");
}
}
finally
{
ReleaseWriteLock();
}
}
finally
{
if (entry != null)
{
entry.CompareExchangeIsInUse(false, true);
}
}
}
else
{
//Is this entry being exported?
if (entry.IsExporting)
{
//This session is already been exported so leave
Diags.ResetDeadLockCounter();
return(SessionActionResult.Exporting);
}
//Another thread is using this session and will be done soon so try again
Thread.Sleep(1); //pause for 1 ms
tryAgain = true;
}
Diags.DetectDeadLock(Key, DeadLockIterationCount); //Signal a deadlock after 2000 iterations
}
} while (tryAgain);
Diags.ResetDeadLockCounter(); //Signal deadlock was freed
return(SessionActionResult.OK);
}
/// <summary>
/// Called by the SessionDictionary.Read() method to complete processing the request,
/// if the requested session was found and read
/// </summary>
/// <param name="Session">The read session object</param>
/// <param name="StateObject">The state object passed from the SessionDictionary.Read() method</param>
private void CompleteReleaseRequest(ISessionObject Session, object StateObject)
{
ServiceMessage msg = (ServiceMessage)StateObject;
//check if LockCookies match
if (Session.IsLocked)
{
if (!Session.UnLock(LockCookie.Value))
{
//Reply with Locked response
Reply(BuildResponse(typeof(LockedResponse), null, Session.CreateResponseInfo(), null));
return;
}
}
//Reply with OK response
Reply(BuildResponse(typeof(OKResponse), null, Session.CreateResponseInfo(), null));
if(Session.ExtraFlags != -1) Session.ExtraFlags = -1; //Disable extraflags
}
public static bool IsAttributeSet(this XmlElement xmlElement, ISessionObject session, string attributeName)
{
var strValue = xmlElement.GetAttributeValue(attributeName);
return(!string.IsNullOrEmpty(strValue) && strValue != session.Session.SessionKey);
}
/// <summary>
/// Called by the SessionDictionary.Read() method to complete processing the request,
/// if the requested session was found and read
/// </summary>
/// <param name="Session">The read session object</param>
/// <param name="StateObject">The state object passed from the SessionDictionary.Read() method</param>
private void CompleteExclusiveReadRequest(ISessionObject Session, object StateObject)
{
ServiceMessage msg = (ServiceMessage)StateObject;
if (Session.IsLocked)
{
Reply(BuildResponse(typeof(LockedResponse), null, Session.CreateResponseInfo(), null));
return;
}
else
{
if (socket.CheckConnection()) //This request locks up sessions so make sure connection is still valid before locking/responding
{
Session.Lock();
//Increment LockCookie until it reaches the maximum LockCookie value;
Session.LockCookie++;
if (Session.LockCookie > MAX_LockCookieValue)
{
Session.LockCookie = 2; //Roll over
}
Reply(BuildResponse(typeof(OKResponse), null, Session.CreateResponseInfo(), Session.Data));
if (Session.ExtraFlags != -1) Session.ExtraFlags = -1; //Disable extraflags
}
else
{
Diags.LogIgnoredMessage(this, "Connection was dropped");
}
}
}
public object ToExcel(ISessionObject sessionObject, RoleType roleType)
{
var dec = (decimal?)sessionObject.Get(roleType);
return(dec / 1000);
}
/// <summary>
/// Copies all data from one Session object to this one
/// </summary>
/// <param name="ObjectToCopy">Session object to copy from</param>
public void CopyFrom(ISessionObject ObjectToCopy)
{
//Do not copy inUse and isExporting properties (they are used internally)
//inuse = ObjectToCopy.IsInUse ? -1 : 0;
//isExporting = ObjectToCopy.IsExporting;
data = ObjectToCopy.Data;
lockCookie = ObjectToCopy.LockCookie;
lockDate = ObjectToCopy.LockDate;
updateDate = ObjectToCopy.UpdateDate;
timeout = ObjectToCopy.TimeOut;
extraFlags = (sbyte)ObjectToCopy.ExtraFlags;
locked = ObjectToCopy.IsLocked;
}
public string OptionName(ISessionObject option) => this.Name + "_" + option.Id.ToString().Replace("-", "_");
/// <summary>
/// Updates or inserts a session in the dictionary
/// </summary>
/// <param name="Key">Session Key</param>
/// <param name="Session">Session object</param>
/// <param name="InsertOnly">Indicates that session should only be inserted if it does not already exist</param>
/// <param name="UpdateIfNotFound">Indicates whether session should be updated if the session was not found. If set to flase, this gives the caller a chance to query the network before trying again </param>
/// <param name="LockedSessionInfo">Locked session information if session is locked</param>
/// <returns>Result of Action</returns>
private SessionActionResult UpSert(string Key, ISessionObject Session, bool InsertOnly, bool UpdateIfNotFound, out SessionResponseInfo LockedSessionInfo)
{
// Look for the session using a reader lock.
// If session is not found, switch to a writer lock and insert item.
// If session is found:
// Perform an atomic compare exchange on the variable 'InUse'
// If session is in Use, try Upsert again from the start.
// If session is not in Use, Perform UpSert and reset InUse
// Also update Sorted session list
if (Key == null)
{
throw new ArgumentNullException("Key");
}
if (Session == null)
{
throw new ArgumentNullException("Session");
}
LockedSessionInfo = null;
bool tryAgain;
Diags.ResetDeadLockCounter();
do
{
tryAgain = false;
AcquireReadLock();
ISessionObject entry;
try
{
dict.TryGetValue(Key, out entry);
}
finally
{
ReleaseReadLock();
}
if (entry == null)
{
if (!UpdateIfNotFound)
{
return(SessionActionResult.NotFound);
}
//Session not found -- insert brand new session object
AcquireWriteLock();
try
{
//Check again to be sure now that the write-lock has been obtained
dict.TryGetValue(Key, out entry);
if (entry != null)
{
//ooops -- another thread inserted a seesion with this key while this thread was trying to obtain the write-lock
//so try again
tryAgain = true;
continue;
}
Session.LockCookie = 1; //For some reason Lockcookie starts counting from 2 -- so set it to 1 now so that it increments to 2 when sought
dict[Key] = Session;
expiryList.Add(DateTime.UtcNow.Add(new TimeSpan(0, Session.TimeOut, 0)), Key, Key);
Diags.LogNewSession(Key, Session);
}
finally
{
ReleaseWriteLock();
}
}
else
{
//Session Found
if (InsertOnly)
{
Diags.LogSessionAlreadyExists(Key);
return(SessionActionResult.AlreadyExists); //Do not perform an update if InsertOnly is requested
}
//There is no need to acquire a write lock here since the dictionary is not been modified.
//Only the dictionary entry itself is been updated and such updates are guaranteed to be atomic
//if the atomic InUse property is set.
if (entry.CompareExchangeIsInUse(true, false) == false)
{
//the InUse flag is set, so this code section has exclusive access to this session object
try
{
if (entry.IsLocked)
{
if (!entry.UnLock(Session.LockCookie))
{
//Lockcookie did not match
LockedSessionInfo = (SessionResponseInfo)entry.CreateResponseInfo();
Diags.LogSessionIsLocked(Key);
return(SessionActionResult.Locked);
}
}
Session.LockCookie = entry.LockCookie; //Overwrite the incoming session's lock-cookie with the internal one's so as not to let external input change the lockcookie
Session.ExtraFlags = -1; //disable extra flags since an update is being performed
entry.CopyFrom(Session); //Copy all information from Session to entry
expiryList.Add(DateTime.UtcNow.Add(new TimeSpan(0, Session.TimeOut, 0)), Key, Key); //reset expiry timeout
Diags.LogUpdatedSession(Key, Session);
}
finally
{
entry.CompareExchangeIsInUse(false, true);
}
}
else
{
//Is this entry being exported?
if (entry.IsExporting)
{
//This session is already been exported so leave
Diags.ResetDeadLockCounter();
return(SessionActionResult.Exporting);
}
//Another thread is using this session and will be done soon so try again
Thread.Sleep(1); //pause for 1 ms
tryAgain = true;
}
}
Diags.DetectDeadLock(Key, DeadLockIterationCount); //Signal a deadlock after 2000 iterations
} while (tryAgain);
Diags.ResetDeadLockCounter(); //Signal deadlock was freed
return(SessionActionResult.OK);
}
public SessionGetter(ISessionReader sessionReader,ISessionObject sessionObject)
{
_sessionReader = sessionReader;
_sessionObject = sessionObject;
}
public SessionGetter(ISessionReader sessionReader, ISessionObject sessionObject)
{
_sessionReader = sessionReader;
_sessionObject = sessionObject;
}
public object ToExcel(ISessionObject sessionObject, RoleType roleType)
{
return(sessionObject.Get(roleType));
}
public static bool IsAttributeSet(this XmlElement xmlElement, ISessionObject session, string attributeName)
{
var strValue = xmlElement.GetAttributeValue(attributeName);
return !string.IsNullOrEmpty(strValue) && strValue != session.Session.SessionKey;
}
/// <summary>
/// Called by the SessionDictionary.BeginExport method to complete processing the request,
/// if the requested session was found and read
/// </summary>
/// <param name="Session">The read session</param>
/// <param name="StateObject">The state object passed from the SessionDictionary.BeginExport method</param>
private void CompleteTransferRequest(ISessionObject Session, object StateObject)
{
ISessionResponseInfo response = Session.CreateResponseInfo();
//Get the endpoint for the host to connect to
string remoteHost;
int? remotePort;
ServerSettings.HostEndPoint.Parse(Host,out remoteHost,out remotePort);
if(!remotePort.HasValue) remotePort = service.Settings.PeerPort;
ServerSettings.HostEndPoint endPoint = new ServerSettings.HostEndPoint(remoteHost.Trim(),remotePort.Value);
const int sentTransferExpiryTime = 2; // 2 seconds is sufficient for a broadcast to traverse half a reasonable network
#region Callback Delegate declarations
//SuccessAction
Action<AsyncMessageTracker> successAction =
delegate(AsyncMessageTracker asyncMsg)
{
//Add this transfer to list of recently transferred sessions and have it expire in 15 seconds
service.SentTransfers.Add(DateTime.UtcNow + new TimeSpan(0, 0, sentTransferExpiryTime), Resource, null);
TransferSuccess(asyncMsg);
Diags.LogTransferSuccess(Resource);
};
//FailedAction
Action<AsyncMessageTracker> failureAction =
delegate(AsyncMessageTracker asyncMsg)
{
TransferFailure(asyncMsg);
Diags.LogTransferFailed(Resource, string.Empty);
};
//AlreadyExistsAction
Action<AsyncMessageTracker> alreadyExistsAction =
delegate(AsyncMessageTracker asyncMsg)
{
//Add this transfer to list of recently transferred sessions and have it expire in 15 seconds
service.SentTransfers.Add(DateTime.UtcNow + new TimeSpan(0, 0, sentTransferExpiryTime), Resource, null);
TransferSuccess(asyncMsg);
Diags.LogTransferFailed(Resource, "Resource already exists in remote peer -- deleted local copy");
};
//PeerShuttingDownAction
Action<AsyncMessageTracker> peerShuttingDownAction =
delegate(AsyncMessageTracker asyncMsg)
{
TransferFailure(asyncMsg);
Diags.LogTransferFailed(Resource, "Peer is shutting down");
};
//TimeoutAction
System.Threading.WaitCallback timeoutAction =
delegate(object asyncMsg)
{
//This anonymous method can be called directly from a background thread so make sure it's exception-safe
try
{
TransferFailure((AsyncMessageTracker)asyncMsg);
Diags.LogTransferFailed(Resource, "Timed out");
}
catch (Exception ex)
{
Diags.LogApplicationError( "TimeoutAction delegate error in CompleteTransferRequest", ex);
}
};
//FailedActionForExistingLink
Action<AsyncMessageTracker> failureActionForExistingLink =
delegate(AsyncMessageTracker asyncMsg)
{
Diags.LogTransferFailed(Resource, "Existing link, trying again on new link");
//Try again by reconnecting
service.TransferSession(endPoint, Resource, response, Session.Data,
successAction, failureAction, alreadyExistsAction, peerShuttingDownAction, timeoutAction);
};
#endregion
service.NewActiveExport(Resource); //create an entry in the exports list for this export
//Look for standing link
ServiceSocket linkSocket;
if(service.TryGetLinkTo(endPoint, out linkSocket))
{
//There is a standing link to this peer so send transfer through it
AsyncMessageTracker msg = new AsyncMessageTracker(AsyncMessageOperation.SetTransferOperation, Guid.NewGuid(), linkSocket);
service.TransferSession(msg, Resource, response, Session.Data,
successAction, failureActionForExistingLink, alreadyExistsAction, peerShuttingDownAction, timeoutAction);
}
else
{
//Initiate a brand new connection
service.TransferSession(endPoint, Resource, response, Session.Data,
successAction,failureAction,alreadyExistsAction,peerShuttingDownAction,timeoutAction);
}
}
