public object AfterReceiveRequest(ref Message request,
IClientChannel channel,
InstanceContext instanceContext)
{
OperationContext.Current.Extensions.Add(new WorkerContext());
return request.Headers.MessageId;
}
public object AfterReceiveRequest(ref Message request,
IClientChannel channel,
InstanceContext instanceContext)
{
request = TraceHttpRequestMessage(request.ToHttpRequestMessage());
return null;
}
public object AfterReceiveRequest(ref System.ServiceModel.Channels.Message request, IClientChannel channel, InstanceContext instanceContext)
{
/* Add request Logging code here
* Message contents in request.ToString()
*/
return null;
}
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
var reply = request.Headers.ReplyTo;
OperationContext.Current.OutgoingMessageHeaders.To = reply.Uri;
OperationContext.Current.OutgoingMessageHeaders.RelatesTo = request.Headers.MessageId;
return null;
}
public object AfterReceiveRequest(ref Message request,
IClientChannel channel,
InstanceContext instanceContext)
{
// Extract Cookie (name=value) from messageproperty
var messageProperty = (HttpRequestMessageProperty)
OperationContext.Current.IncomingMessageProperties[HttpRequestMessageProperty.Name];
string cookie = messageProperty.Headers.Get("Set-Cookie");
if (string.IsNullOrWhiteSpace(cookie))
return null;
string[] nameValue = cookie.Split('=', ',');
string userName = string.Empty;
// Set User Name from cookie
int pos = nameValue.ToList().IndexOf(".ASPXAUTH");
if (pos == -1)
return null;
userName = nameValue[pos + 1];
// Set Thread Principal to User Name
EnterpriseIdentity enterpriseIdentity = new EnterpriseIdentity();
GenericPrincipal threadCurrentPrincipal =
new GenericPrincipal(enterpriseIdentity, new string[] { });
enterpriseIdentity.IsAuthenticated = true;
enterpriseIdentity.Name = userName;
System.Threading.Thread.CurrentPrincipal = threadCurrentPrincipal;
return null;
}
/// <summary>Enables inspection or modification of a message before a request message is sent to a service.</summary>
/// <param name="request">The message to be sent to the service.</param>
/// <param name="channel">The client object channel.</param>
/// <returns>
/// The object that is returned as the <c>correlationState</c> argument of the <see cref="M:System.ServiceModel.Dispatcher.IClientMessageInspector.AfterReceiveReply(System.ServiceModel.Channels.Message@,System.Object)"/> method. This is null if no correlation state is used.The best practice is to make this a <see cref="T:System.Guid"/> to ensure that no two <c>correlationState</c> objects are the same.
/// </returns>
public object BeforeSendRequest( ref Message request, IClientChannel channel )
{
var correlationState = Guid.NewGuid();
this._logger.Trace( @"Request {{{0}}}:
{1}", correlationState.ToString(), request.ToString() );
return correlationState;
}
/// <summary>
/// Add token message at header to using NHibernate cache
/// </summary>
/// <param name="request"></param>
/// <param name="channel"></param>
/// <returns></returns>
public object BeforeSendRequest(ref Message request, IClientChannel channel)
{
// add trace log for debug and performance tuning
if (null != (request.Headers).MessageId && (request.Headers).MessageId.IsGuid)
{
ServiceStopWatch = Stopwatch.StartNew();
Guid messageId;
(request.Headers).MessageId.TryGetGuid(out messageId);
CurrentTraceInfo = new TraceInfo()
{
SessionId = (HttpContext.Current != null && HttpContext.Current.Session != null) ? HttpContext.Current.Session.SessionID : "",
TraceType = TraceType.WcfActionClientCall,
TraceName = request.Headers.Action,
TraceUniqueId = messageId.ToString()
};
TraceLogger.Instance.TraceServiceStart(CurrentTraceInfo, true);
// Add a message header with sessionid
MessageHeader<string> messageHeader = new MessageHeader<string>(CurrentTraceInfo.SessionId);
MessageHeader untyped = messageHeader.GetUntypedHeader("sessionid", "ns");
request.Headers.Add(untyped);
}
return null;
}
public object BeforeSendRequest(ref Message request, IClientChannel channel)
{
var header = MessageHeader.CreateHeader(Constants.ProtocolVersion, Constants.Namespace, Constants.SupportedProtocolVersion);
request.Headers.Add(header);
return null;
}
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
bool shouldCompressResponse = false;
object propObj;
if (request.Properties.TryGetValue(HttpRequestMessageProperty.Name, out propObj))
{
var prop = (HttpRequestMessageProperty)propObj;
var accept = prop.Headers[HttpRequestHeader.Accept];
if (accept != null)
{
if (jsonContentTypes.IsMatch(accept))
{
WebOperationContext.Current.OutgoingResponse.Format = WebMessageFormat.Json;
}
else if (xmlContentTypes.IsMatch(accept))
{
WebOperationContext.Current.OutgoingResponse.Format = WebMessageFormat.Xml;
}
}
var acceptEncoding = prop.Headers[HttpRequestHeader.AcceptEncoding];
if (acceptEncoding != null && acceptEncoding.Contains("gzip"))
{
shouldCompressResponse = true;
}
}
return shouldCompressResponse;
}
/// <summary>
/// Called when an inbound message been received
/// </summary>
/// <param name="request">The request message.</param>
/// <param name="channel">The incoming channel.</param>
/// <param name="instanceContext">The current service instance.</param>
/// <returns>
/// The object used to correlate stateMsg.
/// This object is passed back in the method.
/// </returns>
public object AfterReceiveRequest(ref Message request,
IClientChannel channel,
InstanceContext instanceContext)
{
StateMessage stateMsg = null;
HttpRequestMessageProperty requestProperty = null;
if (request.Properties.ContainsKey(HttpRequestMessageProperty.Name))
{
requestProperty = request.Properties[HttpRequestMessageProperty.Name]
as HttpRequestMessageProperty;
}
if (requestProperty != null)
{
var origin = requestProperty.Headers["Origin"];
if (!string.IsNullOrEmpty(origin))
{
stateMsg = new StateMessage();
// if a cors options request (preflight) is detected,
// we create our own reply message and don't invoke any
// operation at all.
if (requestProperty.Method == "OPTIONS")
{
stateMsg.Message = Message.CreateMessage(request.Version, null);
}
request.Properties.Add("CrossOriginResourceSharingState", stateMsg);
}
}
return stateMsg;
}
public object BeforeSendRequest(ref Message request, IClientChannel channel)
{
var tokenInjector = ServiceLocator.Current.GetInstance<ISecurityTokenInjector>();
if (tokenInjector != null)
{
object httpRequestMessageObject;
if (request.Properties.TryGetValue(HttpRequestMessageProperty.Name, out httpRequestMessageObject))
{
var httpRequestMessage = httpRequestMessageObject as HttpRequestMessageProperty;
if (httpRequestMessage != null)
tokenInjector.InjectToken(httpRequestMessage.Headers);
}
else
{
var httpRequestMessage = new HttpRequestMessageProperty();
tokenInjector.InjectToken(httpRequestMessage.Headers);
request.Properties.Add(HttpRequestMessageProperty.Name, httpRequestMessage);
}
}
return null;
}
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
CorsState state = null;
HttpRequestMessageProperty responseProperty = null;
if (request.Properties.ContainsKey(HttpRequestMessageProperty.Name))
{
responseProperty = request.Properties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty;
}
if (responseProperty != null)
{
//Handle cors requests
var origin = responseProperty.Headers["Origin"];
if (!string.IsNullOrEmpty(origin))
{
state = new CorsState();
//if a cors options request (preflight) is detected, we create our own reply message and don't invoke any operation at all.
if (responseProperty.Method == "OPTIONS")
{
state.Message = Message.CreateMessage(request.Version, FindReplyAction(request.Headers.Action), new EmptyBodyWriter());
}
request.Properties.Add(CrossOriginResourceSharingPropertyName, state);
}
}
return state;
}
public ConversationViewModel(IClientChannel clientChannel,
IForegroundUpdateService foregroundUpdateService,
IVoipChannel voipChannel)
{
_clientChannel = clientChannel;
_voipChannel = voipChannel;
_foregroundUpdateService = foregroundUpdateService;
foregroundUpdateService.OnRelayMessagesUpdated += OnRelayMessagesUpdated;
foregroundUpdateService.OnVoipStateUpdate += OnVoipStateUpdate;
foregroundUpdateService.OnFrameFormatUpdate += OnFrameFormatUpdate;
foregroundUpdateService.OnFrameRateUpdate += OnFrameRateUpdate;
SendInstantMessageCommand = new DelegateCommand(OnSendInstantMessageCommandExecute,
OnSendInstantMessageCommandCanExecute);
AudioCallCommand = new DelegateCommand(OnCallCommandExecute, OnCallCommandCanExecute);
VideoCallCommand = new DelegateCommand(OnVideoCallCommandExecute, OnVideoCallCommandCanExecute);
HangupCommand = new DelegateCommand(OnHangupCommandExecute, OnHangupCommandCanExecute);
AnswerCommand = new DelegateCommand(OnAnswerCommandExecute, OnAnswerCommandCanExecute);
RejectCommand = new DelegateCommand(OnRejectCommandExecute, OnRejectCommandCanExecute);
CloseConversationCommand = new DelegateCommand(OnCloseConversationCommandExecute, () => _canCloseConversation);
MuteMicrophoneCommand = new DelegateCommand(MuteMicCommandExecute, MicCommandCanExecute);
UnMuteMicrophoneCommand = new DelegateCommand(UnMuteCommandExecute, MicCommandCanExecute);
SwitchVideoCommand = new DelegateCommand(SwitchVideoCommandExecute, SwitchVideoCommandCanExecute);
LayoutService.Instance.LayoutChanged += LayoutChanged;
LayoutChanged(LayoutService.Instance.LayoutType);
SetVideoPresenters();
}
/// <summary>
/// Initializes a new instance of the <see cref="RosterViewModel"/> class.
/// </summary>
/// <param name="clientChannel">The client channel.</param>
public RosterViewModel(IClientChannel clientChannel, LoginViewModel loginViewModel)
: this()
{
if (clientChannel == null)
{
throw new ArgumentNullException("clientChannel");
}
if (clientChannel.State != SessionState.Established)
{
throw new ArgumentException("The session is in an invalid state");
}
_clientChannel = clientChannel;
this.Identity = _clientChannel.LocalNode.ToIdentity();
if (loginViewModel == null)
{
throw new ArgumentNullException("loginViewModel");
}
_loginViewModel = loginViewModel;
_cancellationTokenSource = new CancellationTokenSource();
_listenerTask = ListenAsync();
}
/// <summary>
/// Gets a remote host service using the specified channel.
/// </summary>
/// <param name="channel">The channel.</param>
/// <returns>The remote host service.</returns>
public static IRemoteHostService GetRemoteHostService(IClientChannel channel)
{
if (channel == null)
throw new ArgumentNullException("channel");
return (IRemoteHostService)channel.GetService(typeof(IRemoteHostService), ServiceName);
}
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
if (request.Properties.ContainsKey("UriTemplateMatchResults"))
{
HttpRequestMessageProperty httpmsg = (HttpRequestMessageProperty)request.Properties[HttpRequestMessageProperty.Name];
UriTemplateMatch match = (UriTemplateMatch)request.Properties["UriTemplateMatchResults"];
string format = match.QueryParameters["$format"];
if ("json".Equals(format, StringComparison.InvariantCultureIgnoreCase))
{
// strip out $format from the query options to avoid an error
// due to use of a reserved option (starts with "$")
match.QueryParameters.Remove("$format");
// replace the Accept header so that the Data Services runtime
// assumes the client asked for a JSON representation
httpmsg.Headers["Accept"] = "application/json, text/plain;q=0.5";
httpmsg.Headers["Accept-Charset"] = "utf-8";
string callback = match.QueryParameters["$callback"];
if (!string.IsNullOrEmpty(callback))
{
match.QueryParameters.Remove("$callback");
return callback;
}
}
}
return null;
}
public object BeforeSendRequest(ref Message request, IClientChannel channel)
{
MessageBuffer buffer = request.CreateBufferedCopy(Int32.MaxValue);
request = buffer.CreateMessage();
Console.WriteLine("Sending:\n{0}", buffer.CreateMessage().ToString());
return request;
}
public static Log BuildLogRequest(ref Message request, IClientChannel channel)
{
string logName = request.Properties.ContainsKey("HttpOperationName")
? request.Properties["HttpOperationName"].ToString()
: string.Empty;
string serviceName = GetServiceName(request.Headers.To);
var httpReq = (HttpRequestMessageProperty) request.Properties[HttpRequestMessageProperty.Name];
string disableHeaderLog = httpReq.Headers["X-DisableHeaderLog"];
serviceName = string.IsNullOrEmpty(serviceName) ? httpReq.Headers["X-ServiceName"] : serviceName;
logName = string.IsNullOrEmpty(logName) ? httpReq.Headers["X-MethodName"] : logName;
string errorElement = httpReq.Headers["X-SuccessElement"];
var rq = new StringBuilder();
if (string.IsNullOrEmpty(disableHeaderLog))
{
rq.AppendLine(string.Format("{0} {1}", httpReq.Method, request.Headers.To));
foreach (string header in httpReq.Headers.AllKeys)
{
rq.AppendLine(string.Format("{0}: {1}", header, httpReq.Headers[header]));
}
rq.AppendLine("------------------------------------------------------------");
}
if (!request.IsEmpty)
{
rq.AppendLine(MessageToString(ref request));
}
var log = new Log(logName, rq.ToString(), serviceName);
log["SuccessElement"] = errorElement; // Used to set the status of the log after receiving response.
return log;
}
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
if (!request.IsFault && !request.IsEmpty)
LogRequest(ref request);
return null;
}
public object BeforeInvoke(InstanceContext instanceContext,
IClientChannel channel,
Message message)
{
UnitOfWork = Rhino.Commons.UnitOfWork.Start();
return null;
}
public object BeforeSendRequest(
ref Message request,
IClientChannel channel)
{
reqPayload = request.ToString();
return null;
}
public static void End(IAsyncResult asyncResult, out string userName, out string password, out IClientChannel channel)
{
ClientPasswordAsyncResult thisPtr = AsyncResult.End<ClientPasswordAsyncResult>(asyncResult);
userName = thisPtr.passwordForm.UserName;
password = thisPtr.passwordForm.Password;
channel = thisPtr.clientChannel;
}
public object BeforeSendRequest(ref Message request, IClientChannel channel)
{
if (!request.IsEmpty)
{
XmlReader bodyReader = request.GetReaderAtBodyContents().ReadSubtree();
MemoryStream stream = new MemoryStream();
XmlWriter writer = XmlWriter.Create(stream);
if (transform == null)
{
transform = new XslCompiledTransform(true);
var reader = XmlReader.Create(new StringReader(Properties.Resources.XmlCleaner));
transform.Load(reader);
}
transform.Transform(bodyReader, writer);
stream.Flush();
stream.Seek(0, SeekOrigin.Begin);
bodyReader = XmlReader.Create(stream);
Message changedMessage = Message.CreateMessage(request.Version, null, bodyReader);
changedMessage.Headers.CopyHeadersFrom(request.Headers);
changedMessage.Properties.CopyProperties(request.Properties);
request = changedMessage;
}
return null;
}
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
var httpRequest = request.Properties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty;
var authorizationHeader = httpRequest.Headers["Authorization"];
if (string.IsNullOrEmpty(authorizationHeader))
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
string user;
string password;
this.ParseUserPasswordFromHeader(authorizationHeader, out user, out password);
if (string.IsNullOrEmpty(user) || string.IsNullOrEmpty(password))
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
var authenticationService = ObjectFactory.GetInstance<IAuthenticationService>();
if (!authenticationService.Authenticate(user, password))
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
return instanceContext;
}
public object BeforeSendRequest(ref Message request, IClientChannel channel)
{
HttpRequestMessageProperty httpRequestProperty = request.Properties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty;
NameValueCollection rawParameters = HttpUtility.ParseQueryString(request.Headers.To.Query);
UriBuilder uriBuilder = new UriBuilder(request.Headers.To);
uriBuilder.Query = Rfc3986.EncodeAndJoin(rawParameters);
request.Headers.To = uriBuilder.Uri;
OAuthConsumer consumer = new OAuthConsumer(_credentials.OAuthKey, _credentials.OAuthSecret);
int unixTime = UnixTime.ToUnixTime(DateTime.UtcNow);
OAuthParameters parameters = new OAuthParameters();
parameters.Version = Constants.Version1_0;
parameters.SignatureMethod = "RSA-SHA1";
parameters.ConsumerKey = _credentials.OAuthKey;
parameters.Token = _credentials.OAuthToken;
parameters.TokenSecret = _credentials.OAuthTokenSecret;
parameters.Timestamp = unixTime.ToString();
parameters.Nonce = _nonceProvider.GenerateNonce(unixTime);
RsaSha1SigningProvider provider = new RsaSha1SigningProvider();
provider.PfxFile = _credentials.OAuthPfxFile;
provider.PfxPassword = _credentials.OAuthPfxPassword;
parameters.Sign(request.Headers.To, httpRequestProperty.Method, consumer, null, provider);
httpRequestProperty.Headers["Authorization"] = parameters.ToHeaderFormat();
return null;
}
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
var logger = ObjectFactory.GetInstance<ILogger>();
logger.StartAction(request.Headers.To.ToString());
logger.Write("Incoming Message", request.ToString());
return null;
}
public PokerServer(ICommandBus cmdBus, ITableProjection tableProjection, IPlayerConnectionMap playerConnectionMap, IClientChannel clientChannel)
{
_cmdBus = cmdBus;
_tables = tableProjection;
_playerConnectionMap = playerConnectionMap;
_clientChannel = clientChannel;
}
public object BeforeSendRequest(ref Message request, IClientChannel channel)
{
object httpRequestMessageObject;
if (request.Properties.TryGetValue(HttpRequestMessageProperty.Name, out httpRequestMessageObject))
{
HttpRequestMessageProperty httpRequestMessage = httpRequestMessageObject as HttpRequestMessageProperty;
if (httpRequestMessage != null)
{
httpRequestMessage.Headers[SERVICE_KEY_HTTP_HEADER] = (ServiceKey ?? string.Empty);
}
else
{
httpRequestMessage = new HttpRequestMessageProperty();
httpRequestMessage.Headers.Add(SERVICE_KEY_HTTP_HEADER, (ServiceKey ?? string.Empty));
request.Properties[HttpRequestMessageProperty.Name] = httpRequestMessage;
}
}
else
{
HttpRequestMessageProperty httpRequestMessage = new HttpRequestMessageProperty();
httpRequestMessage.Headers.Add(SERVICE_KEY_HTTP_HEADER, (ServiceKey ?? string.Empty));
request.Properties.Add(HttpRequestMessageProperty.Name, httpRequestMessage);
}
return null;
}
public IAsyncResult BeginDisplayInitializationUI (
IClientChannel channel,
AsyncCallback callback,
object state)
{
throw new NotImplementedException ();
}
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
//LocDHT: Retrieve Inbound Object from Request, populate AuthenticationType,UserName,Password
var header = request.Headers.GetHeader<PersonnelHeader>("personnel-header", "s");
if (header != null)
{
var token = OperationContext.Current.ServiceSecurityContext.PrimaryIdentity;
if (token.AuthenticationType == "Windows" ||
token.AuthenticationType == "Negotiate" ||
token.AuthenticationType == "NTLM") // windows authentication
{
header.IsWindowAuthentication = true;
header.Username = ServiceSecurityContext.Current.PrimaryIdentity.Name;
}
else // UserName authentication
{
header.IsWindowAuthentication = false;
header.Username = ServiceSecurityContext.Current.PrimaryIdentity.Name;
if (ServiceSecurityContext.Current.PrimaryIdentity is PersonnelIdentity)
{
header.Password = ((PersonnelIdentity)ServiceSecurityContext.Current.PrimaryIdentity).Password;
}
}
//CustomHeaderServerContextExtension.Current.CustomHeader = header;
OperationContext.Current.IncomingMessageProperties.Add("PersonnelHeader", header);
}
return null;
}
/// <summary>
/// Перед отправкой сообщения включаем в заголовок информацию о текущей трассировке
/// </summary>
/// <param name="request">запрос</param>
/// <param name="channel">канал</param>
/// <returns></returns>
public object BeforeSendRequest(ref Message request, IClientChannel channel)
{
var scope = TraceContextScope.Current;
if (scope == null)
{
return(null);
}
var action = request.Headers.Action;
action = action.Replace("http://tempuri.org/", "");
var id = scope.Id;
var @event = TraceEvent.Create(id: id
, name: "call> " + action);
var callScope = new TraceContextScope(id, @event, TraceContextMode.Add);
var index = request.Headers.FindHeader(TraceMeHeader.HeaderName, Namespace.Main);
if (index > -1)
{
request.Headers.RemoveAt(index);
}
var header = MessageHeader.CreateHeader(
TraceMeHeader.HeaderName, Namespace.Main
, new TraceMeHeader()
{
Id = id,
});
request.Headers.Add(header);
return(callScope);
}
void IDisposable.Dispose()
{
IClientChannel channel = null;
if (this.simplexSessionChannel != null)
{
channel = (IClientChannel)this.simplexSessionChannel;
}
else if (this.duplexSessionChannel != null)
{
channel = (IClientChannel)this.duplexSessionChannel;
}
if (channel != null && channel.State != CommunicationState.Closed)
{
try
{
// Close will abort the channel should an exception be thrown.
channel.Close();
}
catch (CommunicationException)
{ }
}
}
protected override void DisposeCore()
{
IClientChannel channel = (IClientChannel)_channel;
UnhookChannel((ITaxiOnlineService)channel);
try
{
if (channel.State != CommunicationState.Faulted)
{
channel.Close();
}
else
{
channel.Abort();
}
}
catch (CommunicationException)
{
channel.Abort();
}
catch (TimeoutException)
{
channel.Abort();
}
catch (Exception)
{
channel.Abort();
throw;
}
finally
{
channel = null;
_channel = null;
}
// _callbackInstance.Close();
}
public object BeforeSendRequest(ref Message request, IClientChannel channel)
{
// prepare the data to sign
string operation = Regex.Match(request.Headers.Action, "[^/]+$").ToString();
DateTime now = DateTime.UtcNow;
string timestamp = now.ToString("yyyy-MM-ddTHH:mm:ssZ");
string signMe = operation + timestamp;
byte[] bytesToSign = Encoding.UTF8.GetBytes(signMe);
// sign the data
byte[] secretKeyBytes = Encoding.UTF8.GetBytes(secretKey);
HMAC hmacSha256 = new HMACSHA256(secretKeyBytes);
byte[] hashBytes = hmacSha256.ComputeHash(bytesToSign);
string signature = Convert.ToBase64String(hashBytes);
// add the signature information to the request headers
request.Headers.Add(new AmazonHeader("AWSAccessKeyId", accessKeyId));
request.Headers.Add(new AmazonHeader("Timestamp", timestamp));
request.Headers.Add(new AmazonHeader("Signature", signature));
return(null);
}
public async Task <bool> ConnectWithPasswordAsync(Identity identity, string password, CancellationToken cancellationToken)
{
var tcpClient = new TcpClient();
#if DEBUG
ITraceWriter traceWriter = new DebugTraceWriter("Client");
#else
ITraceWriter traceWriter = new FileTraceWriter("client.log");
#endif
var transport = new TcpTransport(
new TcpClientAdapter(tcpClient),
new EnvelopeSerializer(),
hostName: _clientUri.Host,
traceWriter: traceWriter
);
Channel = new ClientChannel(transport, TimeSpan.FromSeconds(60), autoReplyPings: true, autoNotifyReceipt: true);
await Channel.Transport.OpenAsync(_clientUri, cancellationToken);
var resultSession = await Channel.EstablishSessionAsync(
c => c.First(),
e => SessionEncryption.TLS,
identity,
(s, r) => { var auth = new PlainAuthentication(); auth.SetToBase64Password(password); return(auth); },
Environment.MachineName,
cancellationToken);
if (resultSession.State != SessionState.Established)
{
return(false);
}
return(true);
}
public object BeforeSendRequest(ref Message request, IClientChannel channel)
{
object existingMessageProperty;
HttpRequestMessageProperty requestMessageProperty;
if (!request.Properties.TryGetValue(HttpRequestMessageProperty.Name, out existingMessageProperty))
{
requestMessageProperty = new HttpRequestMessageProperty();
request.Properties.Add(HttpRequestMessageProperty.Name, requestMessageProperty);
}
else
{
requestMessageProperty = existingMessageProperty as HttpRequestMessageProperty;
}
if (requestMessageProperty != null)
{
requestMessageProperty.Headers[_headerName] = _headerValue;
}
return(null);
}
public object BeforeSendRequest(ref Message request,
IClientChannel channel)
{
HttpRequestMessageProperty httpRequestMessage = null;
object httpRequestMessageObject;
if (request.Properties.TryGetValue(HttpRequestMessageProperty.Name, out httpRequestMessageObject))
{
httpRequestMessage = httpRequestMessageObject as HttpRequestMessageProperty;
}
if (httpRequestMessage == null)
{
httpRequestMessage = new HttpRequestMessageProperty();
request.Properties.Add(HttpRequestMessageProperty.Name, httpRequestMessage);
}
foreach (var header in _headers)
{
httpRequestMessage.Headers[header.Key] = header.Value;
}
return(null);
}
public object BeforeSendRequest(ref Message request, IClientChannel channel)
{
var action = request.Headers.Action;
currentAction.Value = action;
var policy = OperationPolicy.GetPolicyForAction(action);
var transformer = new MessageTransformer(request);
var requestDocument = transformer.GetXmlDocument();
if (debug)
{
Console.WriteLine("### Request not wrapped: " + XmlUtil.PrettyXml(requestDocument));
}
securityService.WrapRequest(requestDocument, policy);
if (debug)
{
Console.WriteLine("### Request wrapped: " + XmlUtil.AsText(requestDocument));
}
request = transformer.ToMessage(requestDocument);
return(null);
}
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
if (channel is IServiceChannel serviceChannel)
{
if (serviceChannel.ListenUri.Scheme == "net.tcp")
{
string methodName = request.Headers.Action.Split('/').Last();
TypeInfo serviceType = instanceContext.Host.Description.ServiceType as TypeInfo;
foreach (var @interface in serviceType.ImplementedInterfaces)
{
var method = @interface.GetMethod(methodName);
if (method != null)
{
var attributes = method.GetCustomAttributes().Where(x => x.GetType() == typeof(WcfAllowedAttribute)).FirstOrDefault();
if (attributes == null)
{
throw new OnyWebApiException($"Method which was invoked: {methodName}");
}
}
}
}
}
return(request);
}
object IClientMessageInspector.BeforeSendRequest(ref Message request, IClientChannel channel)
{
// Add Query Options if any are set
var messageProperties = OperationContext.Current?.OutgoingMessageProperties;
if (messageProperties != null)
{
messageProperties.TryGetValue(QueryPropertyName, out object queryProperty);
messageProperties.TryGetValue(IncludeTotalCountPropertyName, out object includeTotalCountProperty);
// Add Query Options header if any options were specified
if (queryProperty != null || includeTotalCountProperty != null)
{
var queryParts = queryProperty != null?QuerySerializer.Serialize((IQueryable)queryProperty) : null;
var includeTotalCount = (bool?)includeTotalCountProperty;
var header = new QueryOptionsHeader(queryParts, includeTotalCount == true);
request.Headers.Add(header);
}
}
return(null);
}
public object BeforeSendRequest(ref Message request, IClientChannel channel)
{
HttpRequestMessageProperty httpRequestMessage;
object httpRequestMessageObject;
if (request.Properties.TryGetValue(HttpRequestMessageProperty.Name, out httpRequestMessageObject))
{
httpRequestMessage = httpRequestMessageObject as HttpRequestMessageProperty;
if (httpRequestMessage != null && string.IsNullOrEmpty(httpRequestMessage.Headers["user-agent"]))
{
httpRequestMessage.Headers["user-agent"] = _userAgent;
}
}
else
{
httpRequestMessage = new HttpRequestMessageProperty();
httpRequestMessage.Headers.Add("user-agent", _userAgent);
request.Properties.Add(HttpRequestMessageProperty.Name, httpRequestMessage);
}
return(null);
}
public object AfterReceiveRequest(ref Message message, IClientChannel channel, InstanceContext instanceContext)
{
Console.WriteLine("AfterReceiveRequest");
MessageBuffer buffer = message.CreateBufferedCopy(int.MaxValue);
message = buffer.CreateMessage();
Message messageCopy = buffer.CreateMessage();
string contents;
using (MemoryStream memoryStream = new MemoryStream())
{
XmlWriter writer = XmlWriter.Create(memoryStream);
messageCopy.WriteMessage(writer);
writer.Flush();
memoryStream.Position = 0;
contents = new StreamReader(memoryStream).ReadToEnd();
}
LogFile(contents, "Request");
return(null);
}
/// <summary>
/// После принятия запроса если присутствует флаг TraceMe, создаем окружение трассировки
/// </summary>
/// <param name="request"></param>
/// <param name="channel"></param>
/// <param name="instanceContext"></param>
/// <returns></returns>
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
var index = request.Headers.FindHeader(TraceMeHeader.HeaderName, Namespace.Main);
if (index < 0)
{
return(null);
}
var header = request.Headers.GetHeader <TraceMeHeader>(index);
if (header == null)
{
return(null);
}
var @event = TraceEvent.Create(
id: header.Id
, name: "disp> " + instanceContext.Host.Description.Name);
@event["host"] = HostName;
return(new TraceContextScope(header.Id, @event, TraceContextMode.Add));
}
public async Task AddBuiltHandler_SingleHandler_ShouldExecuteHandler()
{
// Arrange
_transport.Setup(t => t.IsConnected).Returns(true);
IClientChannel handlerClientChannel = null;
var handlerCancellationToken = default(CancellationToken);
Func <IClientChannel, CancellationToken, Task> builtHandler = (clientChannel, cancellationToken) =>
{
handlerClientChannel = clientChannel;
handlerCancellationToken = cancellationToken;
return(TaskUtil.CompletedTask);
};
var target = GetTarget();
// Act
target.AddBuiltHandler(builtHandler);
var channel = await target.BuildAsync(_cancellationToken);
// Assert
handlerClientChannel.ShouldNotBeNull();
handlerClientChannel.ShouldBe(channel);
handlerCancellationToken.ShouldBe(_cancellationToken);
}
/// <summary>
/// Called after an inbound message has been received but before the message is dispatched
/// to the intended operation.
/// </summary>
/// <param name="request">The request message.</param>
/// <param name="channel">The incoming channel.</param>
/// <param name="instanceContext">The current service instance.</param>
/// <returns>
/// The object used to correlate state.
/// This object is passed back in the <see cref="IDispatchMessageInspector.BeforeSendReply"/> method.
/// </returns>
public object AfterReceiveRequest(
ref Message request,
IClientChannel channel,
InstanceContext instanceContext)
{
var httpRequest = (HttpRequestMessageProperty)request.Properties[HttpRequestMessageProperty.Name];
var origin = httpRequest?.Headers[Constants.Origin];
if (origin == null)
{
return(null);
}
var operationName = (string)request.Properties[WebHttpDispatchOperationSelector.HttpOperationNamePropertyName];
if (operationName == null)
{
return(null);
}
if (!_corsEnabledOperationsNames.Contains(operationName, StringComparer.OrdinalIgnoreCase))
{
Facility.LogWriter.LogError($"Failing CORS because the request operation {operationName} is not allowed.");
VmAspectsEventSource.Log.CorsOperationNotAllowed(operationName);
return(null);
}
if (_allowedOrigins != null && _allowedOrigins.Any() && !_allowedOrigins.Contains(origin, StringComparer.OrdinalIgnoreCase))
{
Facility.LogWriter.LogError($"Failing CORS because the request origin {origin} is not explicitly allowed.");
VmAspectsEventSource.Log.CorsOriginNotAllowed(origin);
return(null);
}
return(origin);
}
public object BeforeSendRequest(ref Message request, IClientChannel channel)
{
//remove extra tags VsDebuggerCausalityData
int limit = request.Headers.Count;
for (int i = 0; i < limit; ++i)
{
if (request.Headers[i].Name.Equals("VsDebuggerCausalityData"))
{
request.Headers.RemoveAt(i);
break;
}
}
string st = GetSignElement(MessageString(ref request));
//place for log request
//File.AppendAllText(@"LogRequest.txt", st + Environment.NewLine, Encoding.Default);
request = CreateMessageFromString(st, request.Version);
return(null);
}
public void Intercept(IInvocation invocation)
{
var backendWsHttpBinding = new BasicHttpBinding();
var address = new EndpointAddress("http://localhost:64013/Service1.svc");
var channelFactory = new ChannelFactory <TService>(backendWsHttpBinding, address);
IClientChannel channel = channelFactory.CreateChannel() as IClientChannel;
if (channel != null)
{
try
{
var response = invocation.Method.Invoke(channel, invocation.Arguments);
invocation.ReturnValue = response;
channel.Close();
}
catch (Exception e)
{
channel.Abort();
Console.WriteLine("Error...");
}
}
}
public IAsyncResult BeginWhisper(string from, long fromCID, string to, string message, AsyncCallback callback, object asyncState)
{
if (this.proxy != null)
{
try
{
return(this.proxy.BeginAsyncWhisper(from, fromCID, to, message, callback, asyncState));
}
catch (Exception ex)
{
if (this.Logger != null)
{
this.Logger.Fatal("Fail to BeginWhisper", ex);
}
IClientChannel clientChannel = this.proxy as IClientChannel;
if (clientChannel.State == CommunicationState.Faulted)
{
clientChannel.Abort();
}
return(null);
}
}
throw new Exception("No Service is connected");
}
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
string messageFileName = string.Format("{0}Log{1:000}_Incoming.txt", MessageLogFolder, Interlocked.Increment(ref messageLogFileIndex));
Uri requestUri = request.Headers.To;
using (StreamWriter sw = File.CreateText(messageFileName))
{
HttpRequestMessageProperty httpReq = (HttpRequestMessageProperty)request.Properties[HttpRequestMessageProperty.Name];
sw.WriteLine("{0} {1}", httpReq.Method, requestUri);
foreach (var header in httpReq.Headers.AllKeys)
{
sw.WriteLine("{0}: {1}", header, httpReq.Headers[header]);
}
if (!request.IsEmpty)
{
sw.WriteLine();
sw.WriteLine(this.MessageToString(ref request));
}
}
return(requestUri);
}
public object AfterReceiveRequest(ref Message request, IClientChannel channel,
InstanceContext instanceContext)
{
try
{
ProfilingObject pObject = new ProfilingObject
{
action = OperationContext.Current.IncomingMessageHeaders.Action.Split('/').ToList().Last(),
timer = new AbcTimer()
};
logger.write("RPC call '{0}' started", pObject.action);
pObject.timer.Start();
return(pObject);
} catch (Exception) {
ProfilingObject pObject = new ProfilingObject {
timer = new AbcTimer(), action = "Unknown"
};
logger.write("RPC call '{0}' started", pObject.action);
pObject.timer.Start();
return(pObject);
}
}
/// <summary>
/// After receiving a request, do any message stuff here
/// </summary>
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
try
{
this.m_traceSource.TraceEvent(TraceEventType.Verbose, 0, "Received request from {0} : {1} {2} ({3})", (OperationContext.Current.IncomingMessageProperties[RemoteEndpointMessageProperty.Name] as RemoteEndpointMessageProperty)?.Address.ToString(),
WebOperationContext.Current.IncomingRequest.Method,
WebOperationContext.Current.IncomingRequest.UriTemplateMatch.RequestUri,
WebOperationContext.Current.IncomingRequest.UserAgent);
// Handle compressed requests
var compressionScheme = CompressionUtil.GetCompressionScheme(WebOperationContext.Current.IncomingRequest.Headers[System.Net.HttpRequestHeader.ContentEncoding]);
if (compressionScheme != null)
{
CompressionUtil.DeCompressMessage(ref request, compressionScheme, this.GetContentFormat(request));
}
return(null);
}
catch (Exception e)
{
this.m_traceSource.TraceEvent(TraceEventType.Error, e.HResult, e.ToString());
return(null);
}
}
/// <summary>
/// Inspects inbound message headers and adds an
/// <see cref="TenantIdentificationContextExtension"/>
/// to the current operation context with the tenant ID.
/// </summary>
/// <param name="request">The request message.</param>
/// <param name="channel">The incoming channel.</param>
/// <param name="instanceContext">The current service instance.</param>
/// <returns>
/// Always returns <see langword="null" />. There is no correlation state
/// value to be managed in this inspector.
/// </returns>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="request" /> is <see langword="null" />.
/// </exception>
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var context = OperationContext.Current;
try
{
var tenantId = request.Headers.GetHeader <TTenantId>(TenantHeaderName, TenantHeaderNamespace);
context.Extensions.Add(new TenantIdentificationContextExtension {
TenantId = tenantId
});
}
catch (MessageHeaderException)
{
// The additional header won't be there when we update service
// references; only when the behavior is on the client end.
}
return(null);
}
object IClientMessageInspector.BeforeSendRequest(ref Message request, IClientChannel channel)
{
return(null);
}
public object BeforeSendRequest(ref Message request, IClientChannel channel)
{
return(null);
}
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
return(null);
}
/// <summary>
/// Sets up timeouts.
/// </summary>
/// <param name="channel"></param>
void SetupTimeout(IClientChannel channel)
{
channel.OperationTimeout = new TimeSpan(0, 0, 0, 0, _messageTimeout);
}
/// <summary>
/// 对调用请求进行拦截
/// </summary>
/// <remarks>这里是是在消息头增加一些额外信息</remarks>
/// <param name="request"></param>
/// <param name="channel"></param>
/// <returns></returns>
public object BeforeSendRequest(ref Message request, IClientChannel channel)
{
request.Headers.Add(MessageHeader.CreateHeader(Key, string.Empty, Signature));
return(null);
}
public object BeforeSendRequest(ref Message request, IClientChannel channel)
{
string messageRef = MessageString(ref request);
XmlDocument docRequest = new XmlDocument();
docRequest.LoadXml(messageRef);
WsdlServiceHandle.RequestType type;
DateTime?dateTime = null;
string lnNum = string.Empty;
string lnSnils = string.Empty;
if (messageRef.Contains("getLNListByDate"))
{
type = WsdlServiceHandle.RequestType.GetLnListByDate;
XmlNodeList nodeDate = docRequest.GetElementsByTagName("date");
if (nodeDate != null && nodeDate.Count == 1)
{
dateTime = DateTime.Parse(nodeDate[0].InnerText);
}
}
else if (messageRef.Contains("getLNData"))
{
type = WsdlServiceHandle.RequestType.GetLnData;
XmlNodeList nodeLnCode = docRequest.GetElementsByTagName("lnCode");
if (nodeLnCode != null && nodeLnCode.Count == 1)
{
lnNum = nodeLnCode[0].InnerText;
}
XmlNodeList nodeLnSnils = docRequest.GetElementsByTagName("snils");
if (nodeLnSnils != null && nodeLnCode.Count == 1)
{
lnSnils = nodeLnSnils[0].InnerText;
}
}
else
{
throw new Exception("Неподдерживаемый тип запроса");
}
XmlDocument docCustomSigned = WsdlServiceHandle.GetSignedRequestXml(type, dateTime, lnNum, lnSnils);
XmlDocument docCustomEncrypted =
CryptoTools.EncryptionXML(docCustomSigned, WsdlServiceHandle.fssCert, WsdlServiceHandle.userCert);
request = CreateMessageFromString(docCustomEncrypted.OuterXml, request.Version);
//var _url = "https://docs.fss.ru/WSLnCryptoV11/FileOperationsLnPort?WSDL";
//var _action = "http://ru/ibs/fss/ln/ws/FileOperationsLn.wsdl/getLNListByDate";
////XmlDocument soapEnvelopeXml = CreateSoapEnvelope();
//HttpWebRequest webRequest = CreateWebRequest(_url, _action);
//InsertSoapEnvelopeIntoWebRequest(docCustomEncrypted, webRequest);
//// begin async call to web request.
//IAsyncResult asyncResult = webRequest.BeginGetResponse(null, null);
//// suspend this thread until call is complete. You might want to
//// do something usefull here like update your UI.
//asyncResult.AsyncWaitHandle.WaitOne();
//// get the response from the completed web request.
//string soapResult;
//using (WebResponse webResponse = webRequest.EndGetResponse(asyncResult)) {
// using (StreamReader rd = new StreamReader(webResponse.GetResponseStream())) {
// soapResult = rd.ReadToEnd();
// }
// Console.Write(soapResult);
//}
return(request);
}
public static void SetInstanceId(IClientChannel innerChannel, Guid instanceId)
{
SetContext(innerChannel, InstanceIdKey, instanceId.ToString());
}
//Called by the client to write context over context bindings
public static void SetContext(IClientChannel innerChannel, string key, string value)
{
SetContext(innerChannel, UpdateContext(innerChannel, key, value));
}