/// <summary>
/// Construct a <see cref="BeforeRunAsyncMethodEventArgs"/> object.
/// </summary>
/// <param name="ws">Webservice binding to call.</param>
/// <param name="st">Service type.</param>
/// <param name="ss">Service state object.</param>
/// <param name="r">Webservice requst parameter.</param>
public BeforeRunAsyncMethodEventArgs(SoapHttpClientProtocol ws, MsnServiceType st, MsnServiceState ss, object r)
{
webService = ws;
serviceType = st;
serviceState = ss;
request = r;
}
private void HandleServiceHeader(SoapHttpClientProtocol ws, MsnServiceType st, MsnServiceState ss)
{
ServiceHeader sh = (st == MsnServiceType.AB) ?
((ABServiceBinding)ws).ServiceHeaderValue :
((SharingServiceBinding)ws).ServiceHeaderValue;
if (null != sh &&
NSMessageHandler.ContactService != null &&
NSMessageHandler.ContactService.Deltas != null)
{
if (sh.CacheKeyChanged)
{
NSMessageHandler.ContactService.Deltas.CacheKeys[CacheKeyType.OmegaContactServiceCacheKey] = sh.CacheKey;
}
lock (NSMessageHandler.ContactService.Deltas.SyncObject)
{
/*
* // The implementation here is incorrect, we should only believe in the Location header
* // from the http response.
* if (!String.IsNullOrEmpty(sh.PreferredHostName))
* {
* string methodKey = ws.ToString() + "." + ss.MethodName;
* string preferredHost = FetchHost(sh.PreferredHostName);
* if (NSMessageHandler.ContactService.Deltas.PreferredHosts[methodKey] == preferredHost)
* return;
*
* Trace.WriteLineIf(Settings.TraceSwitch.TraceVerbose, "Update redirect URL by response succeed, method " + ss.MethodName + ":\r\n " +
* "Original: " + FetchHost(ws.Url) + "\r\n " +
* "Redirect: " + preferredHost + "\r\n");
*
* NSMessageHandler.ContactService.Deltas.PreferredHosts[methodKey] = preferredHost;
* }
*/
NSMessageHandler.ContactService.Deltas.Save();
}
}
}
protected void ChangeCacheKeyAndPreferredHostForSpecifiedMethod(SoapHttpClientProtocol ws, MsnServiceType st, MsnServiceState ss, object request)
{
if (st == MsnServiceType.AB ||
st == MsnServiceType.Sharing ||
st == MsnServiceType.Storage)
{
DeltasList deltas = NSMessageHandler.ContactService.Deltas;
if (deltas == null)
{
throw new MSNPSharpException("Deltas is null.");
}
string methodName = ss.MethodName;
string preferredHostKey = ws.ToString() + "." + methodName;
CacheKeyType keyType = (st == MsnServiceType.Storage) ? CacheKeyType.StorageServiceCacheKey : CacheKeyType.OmegaContactServiceCacheKey;
string originalUrl = ws.Url;
string originalHost = FetchHost(ws.Url);
bool needRequest = false;
lock (deltas.SyncObject)
{
needRequest = (deltas.CacheKeys.ContainsKey(keyType) == false ||
deltas.CacheKeys[keyType] == string.Empty ||
(deltas.CacheKeys[keyType] != string.Empty &&
(deltas.PreferredHosts.ContainsKey(preferredHostKey) == false ||
deltas.PreferredHosts[preferredHostKey] == String.Empty)));
}
if (needRequest)
{
try
{
Trace.WriteLineIf(Settings.TraceSwitch.TraceInfo, ws.GetType().ToString() + " is requesting a cachekey and preferred host for calling " + methodName);
switch (keyType)
{
case CacheKeyType.OmegaContactServiceCacheKey:
ws.Url = ws.Url.Replace(originalHost, MSNService.ContactServiceRedirectionHost);
break;
case CacheKeyType.StorageServiceCacheKey:
ws.Url = ws.Url.Replace(originalHost, MSNService.StorageServiceRedirectionHost);
break;
}
ws.GetType().InvokeMember(methodName, System.Reflection.BindingFlags.InvokeMethod,
null, ws,
new object[] { request });
}
catch (Exception ex)
{
bool getHost = false;
if (ex.InnerException is WebException && ex.InnerException != null)
{
WebException webException = ex.InnerException as WebException;
HttpWebResponse webResponse = webException.Response as HttpWebResponse;
if (webResponse != null)
{
if (webResponse.StatusCode == HttpStatusCode.Moved ||
webResponse.StatusCode == HttpStatusCode.MovedPermanently ||
webResponse.StatusCode == HttpStatusCode.Redirect ||
webResponse.StatusCode == HttpStatusCode.RedirectKeepVerb)
{
string redirectUrl = webResponse.Headers[HttpResponseHeader.Location];
if (!string.IsNullOrEmpty(redirectUrl))
{
getHost = true;
lock (deltas.SyncObject)
deltas.PreferredHosts[preferredHostKey] = FetchHost(redirectUrl);
Trace.WriteLineIf(Settings.TraceSwitch.TraceVerbose, "Get redirect URL by HTTP error succeed, method " + methodName + ":\r\n " +
"Original: " + FetchHost(ws.Url) + "\r\n " +
"Redirect: " + FetchHost(redirectUrl) + "\r\n");
}
#region Fetch CacheKey
try
{
XmlDocument errdoc = new XmlDocument();
string errorMessage = ex.InnerException.Message;
string xmlstr = errorMessage.Substring(errorMessage.IndexOf("<?xml"));
xmlstr = xmlstr.Substring(0, xmlstr.IndexOf("</soap:envelope>", StringComparison.InvariantCultureIgnoreCase) + "</soap:envelope>".Length);
//I think the xml parser microsoft used internally is just a super parser, it can ignore everything.
xmlstr = xmlstr.Replace("&", "&");
xmlstr = xmlstr.Replace("&", "&");
errdoc.LoadXml(xmlstr);
XmlNodeList findnodelist = errdoc.GetElementsByTagName("CacheKey");
if (findnodelist.Count > 0 && !String.IsNullOrEmpty(findnodelist[0].InnerText))
{
deltas.CacheKeys[keyType] = findnodelist[0].InnerText;
}
}
catch (Exception exc)
{
Trace.WriteLineIf(Settings.TraceSwitch.TraceError,
"An error occured while getting CacheKey:\r\n" +
"Service: " + ws.GetType().ToString() + "\r\n" +
"MethodName: " + methodName + "\r\n" +
"Message: " + exc.Message);
}
#endregion
}
}
}
if (!getHost)
{
Trace.WriteLineIf(Settings.TraceSwitch.TraceError,
"An error occured while getting CacheKey and Preferred host:\r\n" +
"Service: " + ws.GetType().ToString() + "\r\n" +
"MethodName: " + methodName + "\r\n" +
"Message: " + ex.Message);
lock (deltas.SyncObject)
deltas.PreferredHosts[preferredHostKey] = originalHost; //If there's an error, we must set the host back to its original value.
}
}
deltas.Save();
}
lock (deltas.SyncObject)
{
if (originalHost != null && originalHost != String.Empty)
{
if (deltas.PreferredHosts.ContainsKey(preferredHostKey))
{
ws.Url = originalUrl.Replace(originalHost, FetchHost(deltas.PreferredHosts[preferredHostKey]));
}
else
{
//This means the redirection URL returns respond content.
lock (deltas.SyncObject)
{
deltas.PreferredHosts[preferredHostKey] = ws.Url;
deltas.Save();
}
Trace.WriteLineIf(Settings.TraceSwitch.TraceInfo, "The redirect URL returns correct result, use " + ws.Url + " for " + preferredHostKey);
}
}
// Set cache key
if (st == MsnServiceType.AB)
{
((ABServiceBinding)ws).ABApplicationHeaderValue.CacheKey = deltas.CacheKeys[keyType];
}
else if (st == MsnServiceType.Sharing)
{
((SharingServiceBinding)ws).ABApplicationHeaderValue.CacheKey = deltas.CacheKeys[keyType];
}
else if (st == MsnServiceType.Storage)
{
((StorageService)ws).AffinityCacheHeaderValue.CacheKey = deltas.CacheKeys[keyType];
}
}
}
}
protected internal SoapHttpClientProtocol CreateService(MsnServiceType serviceType, MsnServiceState asyncObject)
{
SoapHttpClientProtocol service = null;
switch (serviceType)
{
case MsnServiceType.AB:
ABServiceBinding abService = new ABServiceBindingWrapper(NSMessageHandler);
abService.Timeout = Int32.MaxValue;
abService.UserAgent = Properties.Resources.WebServiceUserAgent;
abService.ABApplicationHeaderValue = new ABApplicationHeader();
abService.ABApplicationHeaderValue.ApplicationId = NSMessageHandler.Credentials.ClientInfo.ApplicationId;
abService.ABApplicationHeaderValue.IsMigration = false;
abService.ABApplicationHeaderValue.PartnerScenario = Convert.ToString(asyncObject.PartnerScenario);
abService.ABApplicationHeaderValue.CacheKey = NSMessageHandler.ContactService.Deltas.CacheKeys[CacheKeyType.OmegaContactServiceCacheKey];
abService.ABAuthHeaderValue = new ABAuthHeader();
abService.ABAuthHeaderValue.TicketToken = NSMessageHandler.MSNTicket.SSOTickets[SSOTicketType.Contact].Ticket;
abService.ABAuthHeaderValue.ManagedGroupRequest = false;
service = abService;
break;
case MsnServiceType.Sharing:
SharingServiceBinding sharingService = new SharingServiceBindingWrapper(NSMessageHandler);
sharingService.Timeout = Int32.MaxValue;
sharingService.UserAgent = Properties.Resources.WebServiceUserAgent;
sharingService.ABApplicationHeaderValue = new ABApplicationHeader();
sharingService.ABApplicationHeaderValue.ApplicationId = NSMessageHandler.Credentials.ClientInfo.ApplicationId;
sharingService.ABApplicationHeaderValue.IsMigration = false;
sharingService.ABApplicationHeaderValue.PartnerScenario = Convert.ToString(asyncObject.PartnerScenario);
sharingService.ABApplicationHeaderValue.BrandId = NSMessageHandler.MSNTicket.MainBrandID;
sharingService.ABApplicationHeaderValue.CacheKey = NSMessageHandler.ContactService.Deltas.CacheKeys[CacheKeyType.OmegaContactServiceCacheKey];
sharingService.ABAuthHeaderValue = new ABAuthHeader();
sharingService.ABAuthHeaderValue.TicketToken = NSMessageHandler.MSNTicket.SSOTickets[SSOTicketType.Contact].Ticket;
sharingService.ABAuthHeaderValue.ManagedGroupRequest = false;
service = sharingService;
break;
case MsnServiceType.Storage:
StorageService storageService = new StorageServiceWrapper(NSMessageHandler);
storageService.StorageApplicationHeaderValue = new StorageApplicationHeader();
storageService.StorageApplicationHeaderValue.ApplicationID = Properties.Resources.ApplicationStrId;
storageService.StorageApplicationHeaderValue.Scenario = Convert.ToString(asyncObject.PartnerScenario);
storageService.StorageUserHeaderValue = new StorageUserHeader();
storageService.StorageUserHeaderValue.Puid = 0;
storageService.StorageUserHeaderValue.TicketToken = NSMessageHandler.MSNTicket.SSOTickets[SSOTicketType.Storage].Ticket;
storageService.AffinityCacheHeaderValue = new AffinityCacheHeader();
storageService.AffinityCacheHeaderValue.CacheKey = NSMessageHandler.ContactService.Deltas.CacheKeys[CacheKeyType.StorageServiceCacheKey];
service = storageService;
break;
case MsnServiceType.WhatsUp:
WhatsUpServiceBinding wuService = new WhatsUpServiceBindingWrapper(NSMessageHandler);
wuService.Timeout = 60000;
wuService.UserAgent = Properties.Resources.WebServiceUserAgent;
wuService.WNApplicationHeader = new WNApplicationHeaderType();
wuService.WNApplicationHeader.ApplicationId = Properties.Resources.WhatsupServiceAppID;
wuService.WNAuthHeader = new WNAuthHeaderType();
wuService.WNAuthHeader.TicketToken = NSMessageHandler.MSNTicket.SSOTickets[SSOTicketType.WhatsUp].Ticket;
service = wuService;
break;
case MsnServiceType.Directory:
DirectoryService dirService = new DirectoryServiceWrapper(NSMessageHandler);
dirService.Timeout = Int32.MaxValue;
dirService.SOAPApplicationHeaderValue = new SOAPApplicationHeader();
dirService.SOAPApplicationHeaderValue.ApplicationId = Properties.Resources.DirectoryServiceAppID;
dirService.SOAPApplicationHeaderValue.Scenario = Convert.ToString(asyncObject.PartnerScenario);
dirService.SOAPUserHeaderValue = new SOAPUserHeader();
dirService.SOAPUserHeaderValue.TicketToken = NSMessageHandler.MSNTicket.SSOTickets[SSOTicketType.Directory].Ticket;
service = dirService;
break;
}
if (service != null)
{
service.EnableDecompression = Settings.EnableGzipCompressionForWebServices;
if (asyncObject != null && asyncObject.AddToAsyncList)
{
lock (asyncStates)
{
asyncStates[asyncObject] = service;
}
}
}
return(service);
}
public ServiceOperationEventArgs(SoapHttpClientProtocol ws, MsnServiceType st, AsyncCompletedEventArgs e)
{
webService = ws;
serviceType = st;
asyncCompletedEventArgs = e;
}
