public override void CloseConnection() { ((IClientChannel)proxy)?.Close(); proxy = null; factory?.Close(); factory = null; }
public static void DefaultCtor_NetHttps_Echo_RoundTrips_String() { string testString = "Hello"; ChannelFactory<IWcfService> factory = null; IWcfService serviceProxy = null; try { // *** SETUP *** \\ NetHttpsBinding netHttpsBinding = new NetHttpsBinding(); factory = new ChannelFactory<IWcfService>(netHttpsBinding, new EndpointAddress(Endpoints.HttpBaseAddress_NetHttps)); serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ string result = serviceProxy.Echo(testString); // *** VALIDATE *** \\ Assert.True(String.Equals(testString, result), String.Format("Expected result was {0}. Actual was {1}", testString, result)); // *** CLEANUP *** \\ factory.Close(); ((ICommunicationObject)serviceProxy).Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public static void SameBinding_Soap11_EchoString() { CustomBinding binding = null; EndpointAddress endpointAddress = null; ChannelFactory<IWcfService> factory = null; IWcfService serviceProxy = null; string testString = "Hello"; string result = null; try { // *** SETUP *** \\ binding = new CustomBinding(new TextMessageEncodingBindingElement(MessageVersion.Soap11, Encoding.UTF8), new HttpTransportBindingElement()); endpointAddress = new EndpointAddress(Endpoints.HttpSoap11_Address); factory = new ChannelFactory<IWcfService>(binding, endpointAddress); serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ result = serviceProxy.Echo(testString); // *** VALIDATE *** \\ Assert.True(String.Equals(result, testString), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); // *** CLEANUP *** \\ factory.Close(); ((ICommunicationObject)serviceProxy).Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
/*----< processing for receive thread >------------------------*/ /* * - send thread dequeues send message and posts to channel proxy * - thread inspects message and routes to appropriate specified endpoint */ void ThreadProc() { while (true) { CommMessage msg = sndQ.DeQ(); if (msg.Type == CommMessage.MessageType.CloseSender) { break; } if (msg.To == lastUrl) { try { channel.PostMessage(msg); if (msg.AutoDisconnect) { factory?.Close(); lastUrl = ""; } } catch (Exception) { } } else { Close(); if (!Connect(msg.To)) { Console.WriteLine(msg + "... is lost..."); continue; } lastUrl = msg.To; channel.PostMessage(msg); } } }
public static void DigestAuthentication_Echo_RoundTrips_String_No_Domain() { ChannelFactory<IWcfService> factory = null; IWcfService serviceProxy = null; string testString = "Hello"; BasicHttpBinding binding; try { // *** SETUP *** \\ binding = new BasicHttpBinding(BasicHttpSecurityMode.TransportCredentialOnly); binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Digest; factory = new ChannelFactory<IWcfService>(binding, new EndpointAddress(Endpoints.Http_DigestAuth_NoDomain_Address)); factory.Credentials.HttpDigest.ClientCredential = BridgeClientAuthenticationManager.NetworkCredential; serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ string result = serviceProxy.Echo(testString); // *** VALIDATE *** \\ Assert.True(result == testString, string.Format("Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); // *** CLEANUP *** \\ factory.Close(); ((ICommunicationObject)serviceProxy).Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public static void CustomTextMessageEncoder_Http_RequestReply_Buffered() { ChannelFactory<IWcfService> channelFactory = null; IWcfService client = null; string testString = "Hello"; try { // *** SETUP *** \\ CustomBinding binding = new CustomBinding(new CustomTextMessageBindingElement(Encoding.UTF8.WebName), new HttpTransportBindingElement { MaxReceivedMessageSize = ScenarioTestHelpers.SixtyFourMB, MaxBufferSize = ScenarioTestHelpers.SixtyFourMB }); channelFactory = new ChannelFactory<IWcfService>(binding, new EndpointAddress(Endpoints.CustomTextEncoderBuffered_Address)); client = channelFactory.CreateChannel(); // *** EXECUTE *** \\ string result = client.Echo(testString); // *** VALIDATE *** \\ Assert.Equal(result, testString); // *** CLEANUP *** \\ ((ICommunicationObject)client).Close(); channelFactory.Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)client, channelFactory); } }
public static void BasicHttp_DefaultSettings_Echo_RoundTrips_String_StreamedRequest() { string testString = "Hello"; BasicHttpBinding binding = null; ChannelFactory<IWcfService> factory = null; IWcfService serviceProxy = null; Stream stream = null; try { // *** SETUP *** \\ binding = new BasicHttpBinding(BasicHttpSecurityMode.None); binding.TransferMode = TransferMode.StreamedRequest; factory = new ChannelFactory<IWcfService>(binding, new EndpointAddress(Endpoints.HttpBaseAddress_Basic)); serviceProxy = factory.CreateChannel(); stream = StringToStream(testString); // *** EXECUTE *** \\ var result = serviceProxy.GetStringFromStream(stream); // *** VALIDATE *** \\ Assert.Equal(testString, result); // *** CLEANUP *** \\ ((ICommunicationObject)serviceProxy).Close(); factory.Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public static void DefaultSettings_Echo_RoundTrips_String() { string testString = "Hello"; ChannelFactory<IWcfService> factory = null; IWcfService serviceProxy = null; try { // *** SETUP *** \\ NetHttpBinding binding = new NetHttpBinding(); factory = new ChannelFactory<IWcfService>(binding, new EndpointAddress(Endpoints.HttpBaseAddress_NetHttp)); serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ string result = serviceProxy.Echo(testString); // *** VALIDATE *** \\ Assert.NotNull(result); Assert.Equal(testString, result); // *** CLEANUP *** \\ factory.Close(); ((ICommunicationObject)serviceProxy).Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public static void CustomBinding_Message_Interceptor() { ChannelFactory<IWcfChannelExtensibilityContract> factory = null; IWcfChannelExtensibilityContract serviceProxy = null; try { // *** SETUP *** \\ CustomBinding binding = new CustomBinding( new InterceptingBindingElement(new MessageModifier()), new HttpTransportBindingElement()); factory = new ChannelFactory<IWcfChannelExtensibilityContract>(binding, new EndpointAddress(Endpoints.HttpBaseAddress_ChannelExtensibility)); serviceProxy = factory.CreateChannel(); // *** EXECUTE & VALIDATE *** \\ int[] windSpeeds = new int[] { 100, 90, 80, 70, 60, 50, 40, 30, 20, 10 }; for (int i = 0; i < 10; i++) { serviceProxy.ReportWindSpeed(windSpeeds[i]); } // *** CLEANUP *** \\ ((ICommunicationObject)serviceProxy).Close(); factory.Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public static void DefaultSettings_Https_Text_Echo_RoundTrips_String() { string testString = "Hello"; CustomBinding binding = null; ChannelFactory<IWcfService> factory = null; IWcfService serviceProxy = null; try { // *** SETUP *** \\ binding = new CustomBinding(new TextMessageEncodingBindingElement(), new HttpsTransportBindingElement()); factory = new ChannelFactory<IWcfService>(binding, new EndpointAddress(Endpoints.HttpsSoap12_Address)); serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ string result = serviceProxy.Echo(testString); // *** VALIDATE *** \\ Assert.NotNull(result); Assert.Equal(testString, result); // *** CLEANUP *** \\ factory.Close(); ((ICommunicationObject)serviceProxy).Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public static void TextMessageEncoder_WrongContentTypeResponse_Throws_ProtocolException() { ChannelFactory<IWcfService> factory = null; IWcfService serviceProxy = null; string testContentType = "text/blah"; Binding binding = null; try { // *** SETUP *** \\ binding = new BasicHttpBinding(BasicHttpSecurityMode.None); factory = new ChannelFactory<IWcfService>(binding, new EndpointAddress(Endpoints.HttpBaseAddress_Basic)); serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ Assert.Throws<ProtocolException>(() => { serviceProxy.ReturnContentType(testContentType); }); // *** VALIDATE *** \\ // *** CLEANUP *** \\ factory.Close(); ((ICommunicationObject)serviceProxy).Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public static void DefaultSettings_Tcp_Binary_Echo_RoundTrips_String() { string testString = "Hello"; ChannelFactory<IWcfService> factory = null; IWcfService serviceProxy = null; try { // *** SETUP *** \\ CustomBinding binding = new CustomBinding( new SslStreamSecurityBindingElement(), new BinaryMessageEncodingBindingElement(), new TcpTransportBindingElement()); var endpointIdentity = new DnsEndpointIdentity(Endpoints.Tcp_CustomBinding_SslStreamSecurity_HostName); factory = new ChannelFactory<IWcfService>(binding, new EndpointAddress(new Uri(Endpoints.Tcp_CustomBinding_SslStreamSecurity_Address), endpointIdentity)); serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ string result = serviceProxy.Echo(testString); // *** VALIDATE *** \\ Assert.Equal(testString, result); // *** CLEANUP *** \\ ((ICommunicationObject)serviceProxy).Close(); factory.Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public static void DefaultSettings_Echo_RoundTrips_String() { ChannelFactory<IWcfService> factory = null; IWcfService serviceProxy = null; string testString = "Hello"; Binding binding = null; try { // *** SETUP *** \\ binding = new BasicHttpBinding(BasicHttpSecurityMode.None); factory = new ChannelFactory<IWcfService>(binding, new EndpointAddress(Endpoints.HttpBaseAddress_Basic)); serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ string result = serviceProxy.Echo(testString); // *** VALIDATE *** \\ Assert.True(result == testString, String.Format("Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); // *** CLEANUP *** \\ factory.Close(); ((ICommunicationObject)serviceProxy).Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public static void NetTcp_TransportSecurity_StreamedRequest_RoundTrips_String() { string testString = "Hello"; NetTcpBinding binding = null; ChannelFactory<IWcfService> factory = null; IWcfService serviceProxy = null; Stream stream = null; try { // *** SETUP *** \\ binding = binding = new NetTcpBinding(SecurityMode.Transport); binding.TransferMode = TransferMode.StreamedRequest; factory = new ChannelFactory<IWcfService>(binding, new EndpointAddress(Endpoints.Tcp_Transport_Security_Streamed_Address)); serviceProxy = factory.CreateChannel(); stream = StringToStream(testString); // *** EXECUTE *** \\ var result = serviceProxy.GetStringFromStream(stream); // *** VALIDATE *** \\ Assert.Equal(testString, result); // *** CLEANUP *** \\ ((ICommunicationObject)serviceProxy).Close(); factory.Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public static void SecurityModeTransport_Echo_RoundTrips_String() { string testString = "Hello"; ChannelFactory<IWcfService> factory = null; IWcfService serviceProxy = null; try { // *** SETUP *** \\ NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport); factory = new ChannelFactory<IWcfService>(binding, new EndpointAddress(Endpoints.Tcp_DefaultBinding_Address)); serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ string result = serviceProxy.Echo(testString); // *** VALIDATE *** \\ Assert.Equal(testString, result); // *** CLEANUP *** \\ ((ICommunicationObject)serviceProxy).Close(); factory.Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public static void SameBinding_Binary_EchoComplexString() { CustomBinding binding = null; ChannelFactory<IWcfService> factory = null; EndpointAddress endpointAddress = null; IWcfService serviceProxy = null; ComplexCompositeType compositeObject = null; ComplexCompositeType result = null; try { // *** SETUP *** \\ binding = new CustomBinding(new BinaryMessageEncodingBindingElement(), new HttpTransportBindingElement()); endpointAddress = new EndpointAddress(Endpoints.HttpBinary_Address); factory = new ChannelFactory<IWcfService>(binding, endpointAddress); serviceProxy = factory.CreateChannel(); compositeObject = ScenarioTestHelpers.GetInitializedComplexCompositeType(); // *** EXECUTE *** \\ result = serviceProxy.EchoComplex(compositeObject); // *** VALIDATE *** \\ Assert.True(compositeObject.Equals(result), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", compositeObject, result)); // *** CLEANUP *** \\ factory.Close(); ((ICommunicationObject)serviceProxy).Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public static void DigestAuthentication_Echo_RoundTrips_String_No_Domain() { ChannelFactory<IWcfService> factory = null; IWcfService serviceProxy = null; string testString = "Hello"; BasicHttpBinding binding; try { // *** SETUP *** \\ binding = new BasicHttpBinding(BasicHttpSecurityMode.TransportCredentialOnly); binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Digest; factory = new ChannelFactory<IWcfService>(binding, new EndpointAddress(Endpoints.Http_DigestAuth_NoDomain_Address)); string DigestUsernameHeaderName = "DigestUsername"; string DigestPasswordHeaderName = "DigestPassword"; string DigestRealmHeaderName = "DigestRealm"; string username = Guid.NewGuid().ToString("n").Substring(0, 8); string password = Guid.NewGuid().ToString("n").Substring(0, 16); string realm = Guid.NewGuid().ToString("n").Substring(0, 5); factory.Credentials.HttpDigest.ClientCredential = new NetworkCredential(username, password, realm); serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ string result = null; using (var scope = new OperationContextScope((IContextChannel)serviceProxy)) { HttpRequestMessageProperty requestMessageProperty; if (!OperationContext.Current.OutgoingMessageProperties.ContainsKey(HttpRequestMessageProperty.Name)) { requestMessageProperty = new HttpRequestMessageProperty(); OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = requestMessageProperty; } else { requestMessageProperty = (HttpRequestMessageProperty)OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name]; } requestMessageProperty.Headers[DigestUsernameHeaderName] = username; requestMessageProperty.Headers[DigestPasswordHeaderName] = password; requestMessageProperty.Headers[DigestRealmHeaderName] = realm; result = serviceProxy.Echo(testString); } // *** VALIDATE *** \\ Assert.True(result == testString, string.Format("Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); // *** CLEANUP *** \\ factory.Close(); ((ICommunicationObject)serviceProxy).Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public static void WebSocket_Http_RequestReply_BinaryStreamed() { NetHttpBinding binding = null; ChannelFactory<IWSRequestReplyService> channelFactory = null; IWSRequestReplyService client = null; FlowControlledStream uploadStream = null; try { // *** SETUP *** \\ binding = new NetHttpBinding() { MaxReceivedMessageSize = ScenarioTestHelpers.SixtyFourMB, MaxBufferSize = ScenarioTestHelpers.SixtyFourMB, }; binding.WebSocketSettings.TransportUsage = WebSocketTransportUsage.Always; binding.TransferMode = TransferMode.Streamed; binding.MessageEncoding = NetHttpMessageEncoding.Binary; channelFactory = new ChannelFactory<IWSRequestReplyService>(binding, new EndpointAddress(Endpoints.WebSocketHttpRequestReplyBinaryStreamed_Address)); client = channelFactory.CreateChannel(); // *** EXECUTE *** \\ using (Stream stream = client.DownloadStream()) { int readResult; // Read from the stream, 1000 bytes at a time. byte[] buffer = new byte[1000]; do { readResult = stream.Read(buffer, 0, buffer.Length); } while (readResult != 0); } uploadStream = new FlowControlledStream(); uploadStream.ReadThrottle = TimeSpan.FromMilliseconds(500); uploadStream.StreamDuration = TimeSpan.FromSeconds(1); client.UploadStream(uploadStream); // *** VALIDATE *** \\ foreach (string serverLogItem in client.GetLog()) { //Assert.True(serverLogItem != ScenarioTestHelpers.RemoteEndpointMessagePropertyFailure, ScenarioTestHelpers.RemoteEndpointMessagePropertyFailure); Assert.True(!ScenarioTestHelpers.IsLocalHost() || !serverLogItem.Contains(ScenarioTestHelpers.RemoteEndpointMessagePropertyFailure), serverLogItem); } // *** CLEANUP *** \\ ((ICommunicationObject)client).Close(); channelFactory.Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)client, channelFactory); } }
public static void CreateChannel_Of_IRequestChannel_Using_CustomBinding() { ChannelFactory<IRequestChannel> factory = null; ChannelFactory<IRequestChannel> factory2 = null; IRequestChannel channel = null; IRequestChannel channel2 = null; try { CustomBinding binding = new CustomBinding(new BindingElement[] { new TextMessageEncodingBindingElement(MessageVersion.Default, Encoding.UTF8), new HttpTransportBindingElement() }); EndpointAddress endpointAddress = new EndpointAddress(BaseAddress.HttpBaseAddress); // Create the channel factory for the request-reply message exchange pattern. factory = new ChannelFactory<IRequestChannel>(binding, endpointAddress); factory2 = new ChannelFactory<IRequestChannel>(binding, endpointAddress); // Create the channel. channel = factory.CreateChannel(); Assert.True(typeof(IRequestChannel).GetTypeInfo().IsAssignableFrom(channel.GetType().GetTypeInfo()), String.Format("Channel type '{0}' was not assignable to '{1}'", channel.GetType(), typeof(IRequestChannel))); channel2 = factory2.CreateChannel(); Assert.True(typeof(IRequestChannel).GetTypeInfo().IsAssignableFrom(channel2.GetType().GetTypeInfo()), String.Format("Channel type '{0}' was not assignable to '{1}'", channel2.GetType(), typeof(IRequestChannel))); // Validate ToString() string toStringResult = channel.ToString(); string toStringExpected = "System.ServiceModel.Channels.IRequestChannel"; Assert.Equal<string>(toStringExpected, toStringResult); // Validate Equals() Assert.StrictEqual<IRequestChannel>(channel, channel); // Validate Equals(other channel) negative Assert.NotStrictEqual<IRequestChannel>(channel, channel2); // Validate Equals("other") negative Assert.NotStrictEqual<object>(channel, "other"); // Validate Equals(null) negative Assert.NotStrictEqual<IRequestChannel>(channel, null); } finally { if (factory != null) { factory.Close(); } if (factory2 != null) { factory2.Close(); } } }
public static void TcpClientCredentialType_Certificate_EchoString() { #if FULLXUNIT_NOTSUPPORTED bool root_Certificate_Installed = Root_Certificate_Installed(); bool client_Certificate_Installed = Client_Certificate_Installed(); if (!root_Certificate_Installed || !client_Certificate_Installed) { Console.WriteLine("---- Test SKIPPED --------------"); Console.WriteLine("Attempting to run the test in ToF, a ConditionalFact evaluated as FALSE."); Console.WriteLine("Root_Certificate_Installed evaluated as {0}", root_Certificate_Installed); Console.WriteLine("Client_Certificate_Installed evaluated as {0}", client_Certificate_Installed); return; } #endif string clientCertThumb = null; EndpointAddress endpointAddress = null; string testString = "Hello"; ChannelFactory<IWcfService> factory = null; IWcfService serviceProxy = null; try { // *** SETUP *** \\ NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport); binding.Security.Transport.ClientCredentialType = TcpClientCredentialType.Certificate; endpointAddress = new EndpointAddress(new Uri(Endpoints.Tcp_ClientCredentialType_Certificate_Address), new DnsEndpointIdentity(Endpoints.Tcp_VerifyDNS_HostName)); clientCertThumb = ServiceUtilHelper.ClientCertificate.Thumbprint; factory = new ChannelFactory<IWcfService>(binding, endpointAddress); factory.Credentials.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.None; factory.Credentials.ClientCertificate.SetCertificate( StoreLocation.CurrentUser, StoreName.My, X509FindType.FindByThumbprint, clientCertThumb); serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ string result = serviceProxy.Echo(testString); // *** VALIDATE *** \\ Assert.Equal(testString, result); // *** CLEANUP *** \\ ((ICommunicationObject)serviceProxy).Close(); factory.Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
private void OnClosed(object sender, EventArgs eventArgs) { if (_factory?.State == CommunicationState.Faulted) { _factory?.Abort(); } else { _factory?.Close(); } }
public static void NetTcp_TransportSecurity_StreamedRequest_RoundTrips_String() { #if FULLXUNIT_NOTSUPPORTED bool root_Certificate_Installed = Root_Certificate_Installed(); bool client_Certificate_Installed = Client_Certificate_Installed(); bool windows_Authentication_Available = Windows_Authentication_Available(); bool ambient_Credentials_Available = Ambient_Credentials_Available(); if (!root_Certificate_Installed || !client_Certificate_Installed || !windows_Authentication_Available || !ambient_Credentials_Available) { Console.WriteLine("---- Test SKIPPED --------------"); Console.WriteLine("Attempting to run the test in ToF, a ConditionalFact evaluated as FALSE."); Console.WriteLine("Root_Certificate_Installed evaluated as {0}", root_Certificate_Installed); Console.WriteLine("Client_Certificate_Installed evaluated as {0}", client_Certificate_Installed); Console.WriteLine("Windows_Authentication_Available evaluated as {0}", windows_Authentication_Available); Console.WriteLine("Ambient_Credentials_Available evaluated as {0}", ambient_Credentials_Available); return; } #endif string testString = "Hello"; NetTcpBinding binding = null; ChannelFactory<IWcfService> factory = null; IWcfService serviceProxy = null; Stream stream = null; try { // *** SETUP *** \\ binding = binding = new NetTcpBinding(SecurityMode.Transport); binding.TransferMode = TransferMode.StreamedRequest; factory = new ChannelFactory<IWcfService>(binding, new EndpointAddress(Endpoints.Tcp_Transport_Security_Streamed_Address)); serviceProxy = factory.CreateChannel(); stream = StringToStream(testString); // *** EXECUTE *** \\ var result = serviceProxy.GetStringFromStream(stream); // *** VALIDATE *** \\ Assert.Equal(testString, result); // *** CLEANUP *** \\ ((ICommunicationObject)serviceProxy).Close(); factory.Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public static void Message_With_MessageHeaders_RoundTrips() { BasicHttpBinding binding = null; IWcfService_4_4_0 clientProxy = null; RequestBankingData_4_4_0 requestData = null; ChannelFactory<IWcfService_4_4_0> factory = null; // *** SETUP *** \\ try { binding = new BasicHttpBinding(); factory = new ChannelFactory<IWcfService_4_4_0>(binding, new EndpointAddress(Endpoints.HttpBaseAddress_4_4_0_Basic)); clientProxy = factory.CreateChannel(); requestData = new RequestBankingData_4_4_0(); requestData.accountName = "Michael Jordan"; requestData.transactionDate = DateTime.Now; requestData.amount = 100.0M; // post-1.1.0 features requestData.requestSingleValue = "test single value"; requestData.requestMultipleValues = "test,multiple,value".Split(','); requestData.requestArrayMultipleValues = "test,array,multiple,value".Split(','); // *** EXECUTE *** \\ ReplyBankingData_4_4_0 replyData = clientProxy.MessageContractRequestReply(requestData); // *** VALIDATE *** \\ Assert.True(String.Equals(requestData.accountName, replyData.accountName), String.Format("Expected Customer = '{0}', actual = '{1}'", requestData.accountName, replyData.accountName)); Assert.True(requestData.amount == replyData.amount, String.Format("Expected Amount = '{0}', actual = '{1}'", requestData.amount, requestData.amount)); Assert.True(String.Equals(requestData.requestSingleValue, replyData.replySingleValue), String.Format("Expected RequestSingleValue = '{0}', actual = '{1}", requestData.requestSingleValue, replyData.replySingleValue)); ValidateArray("MultipleValue", requestData.requestMultipleValues, replyData.replyMultipleValues); ValidateArray("ArrayMultipleValue", requestData.requestArrayMultipleValues, replyData.replyArrayMultipleValues); // *** CLEANUP *** \\ factory.Close(); ((ICommunicationObject)clientProxy).Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)clientProxy, factory); } }
public static void ServiceContract_TypedProxy_AsyncBeginEnd_Call() { // This test verifies a typed proxy can call a service operation asynchronously using Begin/End StringBuilder errorBuilder = new StringBuilder(); try { CustomBinding customBinding = new CustomBinding(); customBinding.Elements.Add(new TextMessageEncodingBindingElement()); customBinding.Elements.Add(new HttpTransportBindingElement()); ChannelFactory<IWcfServiceBeginEndGenerated> factory = new ChannelFactory<IWcfServiceBeginEndGenerated>(customBinding, new EndpointAddress(BaseAddress.HttpBaseAddress)); IWcfServiceBeginEndGenerated serviceProxy = factory.CreateChannel(); string result = null; ManualResetEvent waitEvent = new ManualResetEvent(false); // The callback is optional with this Begin call, but we want to test that it works. // This delegate should execute when the call has completed, and that is how it gets the result of the call. AsyncCallback callback = (iar) => { result = serviceProxy.EndEcho(iar); waitEvent.Set(); }; IAsyncResult ar = serviceProxy.BeginEcho("Hello", callback, null); // This test requires the callback to be called. // An actual timeout should call the callback, but we still set // a maximum wait time in case that does not happen. bool success = waitEvent.WaitOne(TestHelpers.TestTimeout); if (!success) { errorBuilder.AppendLine("AsyncCallback was not called."); } if (!string.Equals(result, "Hello")) { errorBuilder.AppendLine(String.Format("Expected response from Service: {0} Actual was: {1}", "Hello", result)); } factory.Close(); } catch (Exception ex) { errorBuilder.AppendLine(String.Format("Unexpected exception was caught: {0}", ex.ToString())); } Assert.True(errorBuilder.Length == 0, string.Format("Test Scenario: TypedProxy_AsyncBeginEnd_Call FAILED with the following errors: {0}", errorBuilder)); }
public void Dispose() { if (Service is ICommunicationObject communicationObject) { if (communicationObject.State == CommunicationState.Faulted) { communicationObject.Abort(); } else { communicationObject.Close(); } } _channelFactory?.Close(); }
public static void DefaultSettings_Tcp_Binary_Echo_RoundTrips_String() { #if FULLXUNIT_NOTSUPPORTED bool root_Certificate_Installed = Root_Certificate_Installed(); bool client_Certificate_Installed = Client_Certificate_Installed(); if (!root_Certificate_Installed || !client_Certificate_Installed) { Console.WriteLine("---- Test SKIPPED --------------"); Console.WriteLine("Attempting to run the test in ToF, a ConditionalFact evaluated as FALSE."); Console.WriteLine("Root_Certificate_Installed evaluated as {0}", root_Certificate_Installed); Console.WriteLine("Client_Certificate_Installed evaluated as {0}", client_Certificate_Installed); return; } #endif string testString = "Hello"; ChannelFactory<IWcfService> factory = null; IWcfService serviceProxy = null; try { // *** SETUP *** \\ CustomBinding binding = new CustomBinding( new SslStreamSecurityBindingElement(), new BinaryMessageEncodingBindingElement(), new TcpTransportBindingElement()); var endpointIdentity = new DnsEndpointIdentity(Endpoints.Tcp_CustomBinding_SslStreamSecurity_HostName); factory = new ChannelFactory<IWcfService>(binding, new EndpointAddress(new Uri(Endpoints.Tcp_CustomBinding_SslStreamSecurity_Address), endpointIdentity)); serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ string result = serviceProxy.Echo(testString); // *** VALIDATE *** \\ Assert.Equal(testString, result); // *** CLEANUP *** \\ ((ICommunicationObject)serviceProxy).Close(); factory.Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
static void Main(string[] args) { NetNamedPipeBinding binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None); EndpointAddress address = new EndpointAddress("net.pipe://localhost/test"); using (ChannelFactory<IDownloadManager> factory = new ChannelFactory<IDownloadManager>(binding, address)) { IDownloadManager dm = factory.CreateChannel(); if (dm != null) { string msg = dm.CopyFile("test file"); Console.WriteLine(msg); } factory.Close(); } }
public static void TcpClientCredentialType_Certificate_EchoString() { string clientCertThumb = null; EndpointAddress endpointAddress = null; string testString = "Hello"; ChannelFactory<IWcfService> factory = null; IWcfService serviceProxy = null; try { // *** SETUP *** \\ NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport); binding.Security.Transport.ClientCredentialType = TcpClientCredentialType.Certificate; endpointAddress = new EndpointAddress(new Uri(Endpoints.Tcp_ClientCredentialType_Certificate_Address), new DnsEndpointIdentity(Endpoints.Tcp_VerifyDNS_HostName)); clientCertThumb = ServiceUtilHelper.ClientCertificate.Thumbprint; factory = new ChannelFactory<IWcfService>(binding, endpointAddress); factory.Credentials.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.None; factory.Credentials.ClientCertificate.SetCertificate( StoreLocation.CurrentUser, StoreName.My, X509FindType.FindByThumbprint, clientCertThumb); serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ string result = serviceProxy.Echo(testString); // *** VALIDATE *** \\ Assert.Equal(testString, result); // *** CLEANUP *** \\ ((ICommunicationObject)serviceProxy).Close(); factory.Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public static void DefaultCtor_NetHttps_Echo_RoundTrips_String() { #if FULLXUNIT_NOTSUPPORTED bool root_Certificate_Installed = Root_Certificate_Installed(); bool ssl_Available = SSL_Available(); if (!root_Certificate_Installed || !ssl_Available) { Console.WriteLine("---- Test SKIPPED --------------"); Console.WriteLine("Attempting to run the test in ToF, a ConditionalFact evaluated as FALSE."); Console.WriteLine("Root_Certificate_Installed evaluated as {0}", root_Certificate_Installed); Console.WriteLine("SSL_Available evaluated as {0}", ssl_Available); return; } #endif string testString = "Hello"; ChannelFactory<IWcfService> factory = null; IWcfService serviceProxy = null; try { // *** SETUP *** \\ NetHttpsBinding netHttpsBinding = new NetHttpsBinding(); factory = new ChannelFactory<IWcfService>(netHttpsBinding, new EndpointAddress(Endpoints.HttpBaseAddress_NetHttps)); serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ string result = serviceProxy.Echo(testString); // *** VALIDATE *** \\ Assert.True(String.Equals(testString, result), String.Format("Expected result was {0}. Actual was {1}", testString, result)); // *** CLEANUP *** \\ factory.Close(); ((ICommunicationObject)serviceProxy).Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public static void CustomBinding_DefaultSettings_Echo_RoundTrips_DataContract() { // Verifies a typed proxy can call a service operation echoing a DataContract object synchronously CustomBinding customBinding = null; ChannelFactory<IWcfService> factory = null; IWcfService serviceProxy = null; EndpointAddress endpointAddress = null; CompositeType request = null; CompositeType response = null; try { // *** SETUP *** \\ customBinding = new CustomBinding(); customBinding.Elements.Add(new TextMessageEncodingBindingElement()); customBinding.Elements.Add(new HttpTransportBindingElement()); // Note the service interface used. It was manually generated with svcutil. endpointAddress = new EndpointAddress(Endpoints.DefaultCustomHttp_Address); factory = new ChannelFactory<IWcfService>(customBinding, endpointAddress); serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ request = new CompositeType() { StringValue = "myString", BoolValue = true }; response = serviceProxy.GetDataUsingDataContract(request); // *** VALIDATE *** \\ Assert.True(response != null, "GetDataUsingDataContract(request) returned null"); string expectedStringValue = request.StringValue + "Suffix"; Assert.True(String.Equals(response.StringValue, expectedStringValue), String.Format("Expected CompositeType.StringValue \"{0}\", actual was \"{1}\"", expectedStringValue, response.StringValue)); Assert.True(response.BoolValue == request.BoolValue, String.Format("Expected CompositeType.BoolValue \"{0}\", actual was \"{1}\"", request.BoolValue, response.BoolValue)); // *** CLEANUP *** \\ factory.Close(); ((ICommunicationObject)serviceProxy).Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public static void ServiceContract_TypedProxy_AsyncEndOperation_IntOutArg() { string message = "Hello"; BasicHttpBinding binding = null; ChannelFactory<IServiceContractIntOutService> factory = null; IServiceContractIntOutService serviceProxy = null; int number = 0; try { // *** SETUP *** \\ binding = new BasicHttpBinding(); factory = new ChannelFactory<IServiceContractIntOutService>(binding, new EndpointAddress(Endpoints.ServiceContractAsyncIntOut_Address)); serviceProxy = factory.CreateChannel(); ManualResetEvent waitEvent = new ManualResetEvent(false); // *** EXECUTE *** \\ // This delegate will execute when the call has completed, which is how we get the result of the call. AsyncCallback callback = (iar) => { serviceProxy.EndRequest(out number, iar); waitEvent.Set(); }; IAsyncResult ar = serviceProxy.BeginRequest(message, callback, null); // *** VALIDATE *** \\ Assert.True(waitEvent.WaitOne(ScenarioTestHelpers.TestTimeout), "AsyncCallback was not called."); Assert.True((number == message.Count<char>()), String.Format("The local int variable was not correctly set, expected {0} but got {1}", message.Count<char>(), number)); // *** CLEANUP *** \\ ((ICommunicationObject)serviceProxy).Close(); factory.Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public static void SameBinding_SecurityModeTransport_EchoString() { string testString = "Hello"; ChannelFactory<IWcfService> factory = null; try { NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport); factory = new ChannelFactory<IWcfService>(binding, new EndpointAddress(Endpoints.Tcp_NoSecurity_Address)); IWcfService serviceProxy = factory.CreateChannel(); string result = serviceProxy.Echo(testString); Assert.Equal(testString, result); factory.Close(); } finally { ScenarioTestHelpers.CloseCommunicationObjects(factory); } }
public static void CustomBinding_DefaultSettings_Echo_RoundTrips_DataContract() { // Verifies a typed proxy can call a service operation echoing a DataContract object synchronously StringBuilder errorBuilder = new StringBuilder(); try { CustomBinding customBinding = new CustomBinding(); customBinding.Elements.Add(new TextMessageEncodingBindingElement()); customBinding.Elements.Add(new HttpTransportBindingElement()); // Note the service interface used. It was manually generated with svcutil. ChannelFactory<IWcfService> factory = new ChannelFactory<IWcfService>(customBinding, new EndpointAddress(Endpoints.DefaultCustomHttp_Address)); IWcfService serviceProxy = factory.CreateChannel(); CompositeType request = new CompositeType() { StringValue = "myString", BoolValue = true }; CompositeType response = serviceProxy.GetDataUsingDataContract(request); Assert.True(response != null, "GetDataUsingDataContract(request) returned null"); string expectedStringValue = request.StringValue + "Suffix"; if (!string.Equals(response.StringValue, expectedStringValue)) { errorBuilder.AppendLine(string.Format("Expected CompositeType.StringValue \"{0}\", actual was \"{1}\"", expectedStringValue, response.StringValue)); } if (response.BoolValue != request.BoolValue) { errorBuilder.AppendLine(string.Format("Expected CompositeType.BoolValue \"{0}\", actual was \"{1}\"", request.BoolValue, response.BoolValue)); } factory.Close(); } catch (Exception ex) { errorBuilder.AppendLine(String.Format("Unexpected exception was caught: {0}", ex.ToString())); } Assert.True(errorBuilder.Length == 0, errorBuilder.ToString()); }
// Confirm that the Validate method of the custom X509CertificateValidator is called and that an exception thrown there is handled correctly. public static void TCP_ServiceCertFailedCustomValidate_Throw_Exception() { string testString = "Hello"; NetTcpBinding binding = null; EndpointAddress endpointAddress = null; ChannelFactory<IWcfService> factory = null; IWcfService serviceProxy = null; // *** VALIDATE *** \\ var exception = Assert.Throws<Exception>(() => { // *** SETUP *** \\ binding = new NetTcpBinding(); binding.Security.Mode = SecurityMode.Transport; binding.Security.Transport.ClientCredentialType = TcpClientCredentialType.None; endpointAddress = new EndpointAddress(new Uri(Endpoints.Tcp_VerifyDNS_Address), new DnsEndpointIdentity(Endpoints.Tcp_VerifyDNS_HostName)); factory = new ChannelFactory<IWcfService>(binding, endpointAddress); factory.Credentials.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.Custom; factory.Credentials.ServiceCertificate.Authentication.CustomCertificateValidator = new MyCertificateValidator(); serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ try { var result = serviceProxy.Echo(testString); // *** CLEANUP *** \\ ((ICommunicationObject)serviceProxy).Close(); factory.Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }); // *** ADDITIONAL VALIDATION *** \\ Assert.Equal(MyCertificateValidator.exceptionMsg, exception.Message); }
public void Dispose() => _channelFactory.Close();
private Stream CallWebMethod( Stream requestData, string serviceUrl, string action, string username, string password, Context ctx) { try { Stream responseData; var binding = new BasicHttpBinding(BasicHttpSecurityMode.TransportCredentialOnly); binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Windows; binding.UseDefaultWebProxy = true; var epa = new EndpointAddress(new Uri(serviceUrl)); ChannelFactory <genericContract> cf = null; genericContract channel; Message request; Message response; string responseString; try { cf = new ChannelFactory <genericContract>(binding, epa); cf.Credentials.UserName.UserName = username; cf.Credentials.UserName.Password = password; cf.Open(); channel = cf.CreateChannel(); using (new OperationContextScope((IContextChannel)channel)) { XmlReader r = new XmlTextReader(requestData); request = Message.CreateMessage(MessageVersion.Soap11, action, r); foreach (var header in _soapHeaders) { MessageHeader messageHeader = MessageHeader.CreateHeader(header.HeaderName, header.HeaderNameSpace, header.HeaderInstance); OperationContext.Current.OutgoingMessageHeaders.Add(messageHeader); } response = channel.Invoke(request); string responseStr = response.GetReaderAtBodyContents().ReadOuterXml(); ctx.LogXmlData("Response", responseStr); responseData = StreamHelper.LoadMemoryStream(responseStr); } request.Close(); response.Close(); cf.Close(); } catch (CommunicationException ce) { ctx.LogException(ce); if (cf != null) { cf.Abort(); } throw; } catch (TimeoutException te) { ctx.LogException(te); if (cf != null) { cf.Abort(); } throw; } catch (Exception e) { ctx.LogException(e); if (cf != null) { cf.Abort(); } throw; } return(responseData); } catch (Exception ex) { ctx.LogException(ex); throw; } }
private void Closer() { try { tokens.cancelAll(); } catch (Exception ex1) { ex(System.Reflection.MethodBase.GetCurrentMethod().Name + " " + ex1.ToString()); } this.Invoke((MethodInvoker) delegate() { toolStripDropDownButton1.Enabled = false; toolStripDropDownButton1.Visible = false; toolStrip1.Enabled = false; toolStrip1.Hide(); panel1.Hide(); richTextBox1.Dock = DockStyle.Fill; }); Stopwatch watch = new Stopwatch(); watch.Start(); while (true) { bool done = true; foreach (Thread thr in threads) { if (thr.IsAlive) { done = false; if (watch.Elapsed.TotalSeconds > 5) { l("waiting for thread: " + thr.Name); } } } if (watch.Elapsed.TotalSeconds > 5) { watch.Restart(); } if (done) { break; } else { this.Invoke((MethodInvoker) delegate() { this.Refresh(); }); } Thread.Sleep(500); } watch.Stop(); try { channel.Close(); channelFactory.Close(); } catch { } foreach (KeyValuePair <string, ChromeDriver> kvp in cdrivers) { try { this.Invoke((MethodInvoker) delegate() { try { kvp.Value.Quit(); } catch { } }); } catch { } } g("Ready to exit"); this.Invoke((MethodInvoker) delegate() { this.ControlBox = true; }); }
public static void Abort_During_Implicit_Open_Closes_Sync_Waiters() { // This test is a regression test of an issue with CallOnceManager. // When a single proxy is used to make several service calls without // explicitly opening it, the CallOnceManager queues up all the requests // that happen while it is opening the channel (or handling previously // queued service calls. If the channel was closed or faulted during // the handling of any queued requests, it caused a pathological worst // case where every queued request waited for its complete SendTimeout // before failing. // // This test operates by making multiple concurrent synchronous service // calls, but stalls the Opening event to allow them to be queued before // any of them are allowed to proceed. It then aborts the channel when // the first service operation is allowed to proceed. This causes the // CallOnce manager to deal with all its queued operations and cause // them to complete other than by timing out. BasicHttpBinding binding = null; ChannelFactory <IWcfService> factory = null; IWcfService serviceProxy = null; int timeoutMs = 20000; long operationsQueued = 0; int operationCount = 5; Task <string>[] tasks = new Task <string> [operationCount]; Exception[] exceptions = new Exception[operationCount]; string[] results = new string[operationCount]; bool isClosed = false; DateTime endOfOpeningStall = DateTime.Now; int serverDelayMs = 100; TimeSpan serverDelayTimeSpan = TimeSpan.FromMilliseconds(serverDelayMs); string testMessage = "testMessage"; try { // *** SETUP *** \\ binding = new BasicHttpBinding(BasicHttpSecurityMode.None); binding.TransferMode = TransferMode.Streamed; // SendTimeout is the timeout used for implicit opens binding.SendTimeout = TimeSpan.FromMilliseconds(timeoutMs); factory = new ChannelFactory <IWcfService>(binding, new EndpointAddress(Endpoints.HttpBaseAddress_Basic)); serviceProxy = factory.CreateChannel(); // Force the implicit open to stall until we have multiple concurrent calls pending. // This forces the CallOnceManager to have a queue of waiters it will need to notify. ((ICommunicationObject)serviceProxy).Opening += (s, e) => { // Wait until we see sync calls have been queued DateTime startOfOpeningStall = DateTime.Now; while (true) { endOfOpeningStall = DateTime.Now; // Don't wait forever -- if we stall longer than the SendTimeout, it means something // is wrong other than what we are testing, so just fail early. if ((endOfOpeningStall - startOfOpeningStall).TotalMilliseconds > timeoutMs) { Assert.True(false, "The Opening event timed out waiting for operations to queue, which was not expected for this test."); } // As soon as we have all our Tasks at least running, wait a little // longer to allow them finish queuing up their waiters, then stop stalling the Opening if (Interlocked.Read(ref operationsQueued) >= operationCount) { Task.Delay(500).Wait(); endOfOpeningStall = DateTime.Now; return; } Task.Delay(100).Wait(); } }; // Each task will make a synchronous service call, which will cause all but the // first to be queued for the implicit open. The first call to complete then closes // the channel so that it is forced to deal with queued waiters. Func <string> callFunc = () => { // We increment the # ops queued before making the actual sync call, which is // technically a short race condition in the test. But reversing the order would // timeout the implicit open and fault the channel. Interlocked.Increment(ref operationsQueued); // The call of the operation is what creates the entry in the CallOnceManager queue. // So as each Task below starts, it increments the count and adds a waiter to the // queue. We ask for a small delay on the server side just to introduce a small // stall after the sync request has been made before it can complete. Otherwise // fast machines can finish all the requests before the first one finishes the Close(). string result = serviceProxy.EchoWithTimeout("test", serverDelayTimeSpan); lock (tasks) { if (!isClosed) { try { isClosed = true; ((ICommunicationObject)serviceProxy).Abort(); } catch { } } } return(result); }; // *** EXECUTE *** \\ DateTime startTime = DateTime.Now; for (int i = 0; i < operationCount; ++i) { tasks[i] = Task.Run(callFunc); } for (int i = 0; i < operationCount; ++i) { try { results[i] = tasks[i].GetAwaiter().GetResult(); } catch (Exception ex) { exceptions[i] = ex; } } // *** VALIDATE *** \\ double elapsedMs = (DateTime.Now - endOfOpeningStall).TotalMilliseconds; // Before validating that the issue was fixed, first validate that we received the exceptions or the // results we expected. This is to verify the fix did not introduce a behavioral change other than the // elimination of the long unnecessary timeouts after the channel was closed. int nFailures = 0; for (int i = 0; i < operationCount; ++i) { if (exceptions[i] == null) { Assert.True((String.Equals("test", results[i])), String.Format("Expected operation #{0} to return '{1}' but actual was '{2}'", i, testMessage, results[i])); } else { ++nFailures; TimeoutException toe = exceptions[i] as TimeoutException; Assert.True(toe == null, String.Format("Task [{0}] should not have failed with TimeoutException", i)); } } Assert.True(nFailures > 0, String.Format("Expected at least one operation to throw an exception, but none did. Elapsed time = {0} ms.", elapsedMs)); Assert.True(nFailures < operationCount, String.Format("Expected at least one operation to succeed but none did. Elapsed time = {0} ms.", elapsedMs)); // The original issue was that sync waiters in the CallOnceManager were not notified when // the channel became unusable and therefore continued to time out for the full amount. // Additionally, because they were executed sequentially, it was also possible for each one // to time out for the full amount. Given that we closed the channel, we expect all the queued // waiters to have been immediately waked up and detected failure. int expectedElapsedMs = (operationCount * serverDelayMs) + timeoutMs / 2; Assert.True(elapsedMs < expectedElapsedMs, String.Format("The {0} operations took {1} ms to complete which exceeds the expected {2} ms", operationCount, elapsedMs, expectedElapsedMs)); // *** CLEANUP *** \\ ((ICommunicationObject)serviceProxy).Close(); factory.Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public static void ClientCertificate_EchoString() { #if FULLXUNIT_NOTSUPPORTED bool root_Certificate_Installed = Root_Certificate_Installed(); bool client_Certificate_Installed = Client_Certificate_Installed(); bool server_Accepts_Certificates = Server_Accepts_Certificates(); bool ssl_Available = SSL_Available(); if (!root_Certificate_Installed || !client_Certificate_Installed || !server_Accepts_Certificates || !ssl_Available) { Console.WriteLine("---- Test SKIPPED --------------"); Console.WriteLine("Attempting to run the test in ToF, a ConditionalFact evaluated as FALSE."); Console.WriteLine("Root_Certificate_Installed evaluated as {0}", root_Certificate_Installed); Console.WriteLine("Client_Certificate_Installed evaluated as {0}", client_Certificate_Installed); Console.WriteLine("Server_Accepts_Certificates evaluated as {0}", server_Accepts_Certificates); Console.WriteLine("SSL_Available evaluated as {0}", ssl_Available); return; } #endif string clientCertThumb = null; EndpointAddress endpointAddress = null; string testString = "Hello"; ChannelFactory <IWcfService> factory = null; IWcfService serviceProxy = null; try { // *** SETUP *** \\ BasicHttpsBinding basicHttpsBinding = new BasicHttpsBinding(BasicHttpsSecurityMode.Transport); basicHttpsBinding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Certificate; endpointAddress = new EndpointAddress(new Uri(Endpoints.Https_ClientCertificateAuth_Address)); clientCertThumb = ServiceUtilHelper.ClientCertificate.Thumbprint; factory = new ChannelFactory <IWcfService>(basicHttpsBinding, endpointAddress); factory.Credentials.ClientCertificate.SetCertificate( StoreLocation.CurrentUser, StoreName.My, X509FindType.FindByThumbprint, clientCertThumb); serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ string result = serviceProxy.Echo(testString); // *** VALIDATE *** \\ Assert.Equal(testString, result); // *** CLEANUP *** \\ ((ICommunicationObject)serviceProxy).Close(); factory.Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
/// <summary> /// Close the instance for OpeningStock Factory /// </summary> public void OpeningStockServiceInstanceClosed() { _channelFactoryOpeningStock.Close(); }
public static void BasicHttp_Close_ChannelFactory_Operations_Active() { // Test creates 2 channels from a single channel factory and // closes the channel factory while both channels are executing // operations. This verifies the operations are cancelled and // the channel factory is in the correct state. BasicHttpBinding binding = null; TimeSpan delayOperation = TimeSpan.FromSeconds(3); ChannelFactory <IWcfService> factory = null; IWcfService serviceProxy1 = null; IWcfService serviceProxy2 = null; string expectedEcho1 = "first"; string expectedEcho2 = "second"; try { // *** SETUP *** \\ binding = new BasicHttpBinding(BasicHttpSecurityMode.None); binding.CloseTimeout = ScenarioTestHelpers.TestTimeout; binding.SendTimeout = ScenarioTestHelpers.TestTimeout; factory = new ChannelFactory <IWcfService>(binding, new EndpointAddress(Endpoints.HttpBaseAddress_Basic_Text)); serviceProxy1 = factory.CreateChannel(); serviceProxy2 = factory.CreateChannel(); // *** EXECUTE *** \\ Task <string> t1 = serviceProxy1.EchoWithTimeoutAsync(expectedEcho1, delayOperation); Task <string> t2 = serviceProxy2.EchoWithTimeoutAsync(expectedEcho2, delayOperation); factory.Close(); // *** VALIDATE *** \\ Assert.True(factory.State == CommunicationState.Closed, String.Format("Expected factory state 'Closed', actual was '{0}'", factory.State)); Exception exception1 = null; Exception exception2 = null; string actualEcho1 = null; string actualEcho2 = null; // Verification is slightly more complex for the close with active operations because // we don't know which might have completed first and whether the channel factory // was able to close and dispose either channel before it completed. So we just // ensure the Tasks complete with an exception or a successful return and have // been closed by the factory. try { actualEcho1 = t1.GetAwaiter().GetResult(); } catch (Exception e) { exception1 = e; } try { actualEcho2 = t2.GetAwaiter().GetResult(); } catch (Exception e) { exception2 = e; } Assert.True(exception1 != null || actualEcho1 != null, "First operation should have thrown Exception or returned an echo"); Assert.True(exception2 != null || actualEcho2 != null, "Second operation should have thrown Exception or returned an echo"); Assert.True(actualEcho1 == null || String.Equals(expectedEcho1, actualEcho1), String.Format("First operation returned '{0}' but expected '{1}'.", expectedEcho1, actualEcho1)); Assert.True(actualEcho2 == null || String.Equals(expectedEcho2, actualEcho2), String.Format("Second operation returned '{0}' but expected '{1}'.", expectedEcho2, actualEcho2)); Assert.True(((ICommunicationObject)serviceProxy1).State == CommunicationState.Closed, String.Format("Expected channel 1 state 'Closed', actual was '{0}'", ((ICommunicationObject)serviceProxy1).State)); Assert.True(((ICommunicationObject)serviceProxy2).State == CommunicationState.Closed, String.Format("Expected channel 2 state 'Closed', actual was '{0}'", ((ICommunicationObject)serviceProxy2).State)); // *** CLEANUP *** \\ ((ICommunicationObject)serviceProxy1).Abort(); ((ICommunicationObject)serviceProxy2).Abort(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy1, (ICommunicationObject)serviceProxy2, factory); } }
public static void BasicHttp_Streamed_Async_Delayed_And_Aborted_Request_Throws_TimeoutException() { // This test is a regression test that verifies an issue discovered where exceeding the timeout // and aborting the channel before the client's Task completed led to incorrect error handling. BasicHttpBinding binding = null; ChannelFactory <IWcfService> factory = null; IWcfService serviceProxy = null; Stream stream = null; int sendTimeoutMs = 3000; try { // *** SETUP *** \\ binding = new BasicHttpBinding(BasicHttpSecurityMode.None); binding.TransferMode = TransferMode.Streamed; binding.SendTimeout = TimeSpan.FromMilliseconds(sendTimeoutMs); factory = new ChannelFactory <IWcfService>(binding, new EndpointAddress(Endpoints.HttpBaseAddress_Basic_Text)); serviceProxy = factory.CreateChannel(); // Create a read stream that will both timeout and then abort the proxy channel when the // async read is called. We also intercept the synchronous read because that path can also // be executed during an async read. stream = new TestMockStream() { CopyToAsyncFunc = (Stream destination, int bufferSize, CancellationToken ct) => { // Abort to force the internal HttpClientChannelAsyncRequest.Cleanup() // to clear its data structures before the client's Task completes. Task.Delay(sendTimeoutMs * 2).Wait(); ((ICommunicationObject)serviceProxy).Abort(); return(null); }, ReadFunc = (byte[] buffer, int offset, int count) => { // Abort to force the internal HttpClientChannelAsyncRequest.Cleanup() // to clear its data structures before the client's Task completes. Task.Delay(sendTimeoutMs * 2).Wait(); ((ICommunicationObject)serviceProxy).Abort(); return(-1); } }; // *** EXECUTE *** \\ Assert.Throws <TimeoutException>(() => { var unused = serviceProxy.EchoStreamAsync(stream).GetAwaiter().GetResult(); }); // *** VALIDATE *** \\ // *** CLEANUP *** \\ ((ICommunicationObject)serviceProxy).Close(); factory.Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
/// <summary> /// Close the instance for Category Factory /// </summary> public void CategoryServiceInstanceClosed() { _channelFactoryCategory.Close(); }
public static void MyClassCleanup() { // Close Proxy connection proxy.Close(); }
public static void Close() { factory?.Close(); }
public AutotaskAPIClient(string Username, string Password, AutotaskIntegrationKey IntegrationKey) { if (string.IsNullOrWhiteSpace(Username)) { throw new ArgumentNullException("Username cannot by empty"); } if (string.IsNullOrWhiteSpace(Password)) { throw new ArgumentNullException("Password cannot by empty"); } string _integrationKey = IntegrationKey.GetIntegrationKey(); if (string.IsNullOrWhiteSpace(_integrationKey)) { throw new ArgumentNullException("IntegrationKey cannot by empty"); } _atwsUsername = Username; _atwsPassword = Password; _atwsIntegrationKey = _integrationKey; _atwsIntegrations.IntegrationCode = _integrationKey; NetworkCredential _credential = new NetworkCredential(_atwsUsername, _atwsPassword); try { _atwsHttpBinding = new BasicHttpBinding(BasicHttpSecurityMode.Transport) { MaxBufferSize = int.MaxValue, MaxReceivedMessageSize = int.MaxValue }; _atwsHttpBinding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Basic; _atwsChannelFactory = new ChannelFactory <ATWSSoapChannel>(_atwsHttpBinding, new EndpointAddress(new Uri("https://webservices.autotask.net/ATServices/1.6/atws.asmx"))); _atwsChannelFactory.Credentials.UserName.UserName = _atwsUsername; _atwsChannelFactory.Credentials.UserName.Password = _atwsPassword; _atwsServicesClient = _atwsChannelFactory.CreateChannel(); _atwsServicesClient.Open(); _atwsZoneInfo = _atwsServicesClient.getZoneInfo(_atwsUsername); if (_atwsZoneInfo.ErrorCode >= 0) { _atwsServicesClient.Close(); _atwsChannelFactory.Close(); _atwsChannelFactory = new ChannelFactory <ATWSSoapChannel>(_atwsHttpBinding, new EndpointAddress(new Uri(_atwsZoneInfo.URL))); _atwsChannelFactory.Credentials.UserName.UserName = _atwsUsername; _atwsChannelFactory.Credentials.UserName.Password = _atwsPassword; _atwsServicesClient = _atwsChannelFactory.CreateChannel(); _atwsServicesClient.Open(); if (!Preload()) { throw new Exception("Error with data Preload()"); } } else { throw new Exception("Error with getZoneInfo()"); } } catch { throw new ArgumentException("Username must be invalid, unable to get ZoneInfo"); } }
public static void CustomTextMessageEncoder_Http_RequestReply_Streamed() { // 84K, larger than any buffers, but won't allocate in LOH int streamKBytes = 84; int streamLength = 1024 * streamKBytes; int lowestPrintable = ' '; int printableRange = '~' - lowestPrintable; ChannelFactory <IWcfService> factory = null; IWcfService serviceProxy = null; Stream stream = null; try { // *** SETUP *** \\ CustomBinding binding = new CustomBinding(new CustomTextMessageBindingElement(Encoding.UTF8.WebName), new HttpTransportBindingElement { MaxReceivedMessageSize = ScenarioTestHelpers.SixtyFourMB, MaxBufferSize = ScenarioTestHelpers.SixtyFourMB, TransferMode = TransferMode.Streamed }); factory = new ChannelFactory <IWcfService>(binding, new EndpointAddress(Endpoints.CustomTextEncoderStreamed_Address)); serviceProxy = factory.CreateChannel(); byte[] requestBytes = new byte[streamLength]; RandomNumberGenerator rnd = RandomNumberGenerator.Create(); int pos = 0; for (int i = 0; i < streamKBytes; i++) { byte[] tempBuffer = new byte[1024]; rnd.GetBytes(tempBuffer); for (int j = 0; j < 1024; j++) { byte val = tempBuffer[j]; if (val < ' ' || val > '~') { // Force the value to be between ' ' and '~' int temp1 = val % printableRange; val = (byte)(temp1 + lowestPrintable); } requestBytes[pos++] = val; } } stream = new MemoryStream(requestBytes); // *** EXECUTE *** \\ var returnStream = serviceProxy.EchoStream(stream); // *** VALIDATE *** \\ MemoryStream ms = new MemoryStream(streamLength); returnStream.CopyTo(ms); Assert.True(streamLength == ms.Length, String.Format("Expected returned stream length = {0}, actual = {1}", streamLength, ms.Length)); ArraySegment <byte> returnedByteArraySegment; ms.TryGetBuffer(out returnedByteArraySegment); Assert.True(requestBytes.SequenceEqual(returnedByteArraySegment.Array), "Returned bytes are different than sent bytes"); // *** CLEANUP *** \\ ((ICommunicationObject)serviceProxy).Close(); factory.Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
protected void Close() { _channelFactory.Close(); _userService = null; }
protected override void OnClose(TimeSpan timeout) { _innerChannelFactory.Close(timeout); }
public async Task Run(string connectionString) { var sbb = new ServiceBusConnectionStringBuilder(connectionString); try { // Create sender to Sequence Service using (var sendChannelFactory = new ChannelFactory <ISequenceServiceChannel>("sequenceSendClient")) { sendChannelFactory.Endpoint.Address = new EndpointAddress( new Uri(sbb.GetAbsoluteRuntimeEndpoints()[0], SessionQueueName)); sendChannelFactory.Endpoint.EndpointBehaviors.Add( new TransportClientEndpointBehavior(TokenProvider.CreateSharedAccessSignatureTokenProvider(sbb.SharedAccessKeyName, sbb.SharedAccessKey))); using (var clientChannel = sendChannelFactory.CreateChannel()) { for (int j = 0; j < 3; j++) { var contextId = Guid.NewGuid().ToString(); // Send messages var sequenceLength = new Random().Next(5, 10); for (var i = 0; i < sequenceLength; i++) { // Generating a random sequence item var sequenceItem = new SequenceItem( string.Format("{0:00000}", new Random().Next(0, 10000)), new Random().Next(1, 100)); // set the operation context for the subsequent call, this MUST be a new context OperationContext.Current = new OperationContext(clientChannel) { OutgoingMessageProperties = { { BrokeredMessageProperty.Name, new BrokeredMessageProperty { SessionId = contextId, TimeToLive = TimeSpan.FromMinutes(5) } } } }; // Correlating ServiceBus SessionId to ContextId await clientChannel.SubmitSequenceItemAsync(sequenceItem); Console.WriteLine("Sequence: {0} [{1}] - ContextId {2}.", sequenceItem.ItemId, sequenceItem.Quantity, contextId); } // set the operation context for the subsequent call, this MUST be a new context OperationContext.Current = new OperationContext(clientChannel) { OutgoingMessageProperties = { { BrokeredMessageProperty.Name, new BrokeredMessageProperty { SessionId = contextId, TimeToLive = TimeSpan.FromMinutes(5) } } } }; await clientChannel.TerminateSequenceAsync(); } clientChannel.Close(); } // Close sender sendChannelFactory.Close(); } } catch (Exception exception) { Console.WriteLine("Exception occurred: {0}", exception); } }
public override void RunJob() { //prepare new jobs base.MakeNextJobReady(); var nextJob = this.azureStorage.GetNextJob(); if (nextJob == null) { return; } //update host information hosts = this.azureStorage.GetHosts(); if (!hosts.All(x => x.ReadyJobs.Split(',').Contains(nextJob.RowKey))) { azureStorage.WriteLog("Job " + nextJob.RowKey + " not ready on all nodes"); return; } //run the job! var executable = Path.Combine(GetJobDirectory(nextJob.RowKey), nextJob.Executable); azureStorage.WriteLog("Starting " + nextJob.RowKey + " with exe =" + executable + ", params=" + nextJob.Parameters ?? ""); string blobName = null; try { //connect to runner ChannelFactory <IMPIRunner> pipeFactory = new ChannelFactory <IMPIRunner>( new NetNamedPipeBinding(), new EndpointAddress("net.pipe://localhost/MPIRunner") ); //connect to the MPI Wrapper processs using Interface IMPIRunner IMPIRunner runner = pipeFactory.CreateChannel(); //run the exe using the Wrapper switch (nextJob.JobType) { case (int)JobItem.Type.MPI: runner.RunApplication(executable, nextJob.Parameters, hosts.Select(x => x.Address).ToArray(), nextJob.CorePerNode, nextJob.NumNodes); break; case (int)JobItem.Type.Normal: runner.RunApplication(executable, nextJob.Parameters); break; } //Wait for the exe to terminate while (runner.GetState() == RunnerState.Running) { azureStorage.WriteLog("Job " + nextJob.RowKey + " running..."); //var lastOutput = runner.GetCurrentStandardOutput(); //azureStorage.WriteLog(lastOutput); Thread.Sleep(10000); } //retrieve results and upload to blob storage azureStorage.WriteLog("Uploading job results"); blobName = nextJob.RowKey + "-" + DateTime.Now.ToString("HHMMss") + "-" + nextJob.InfoTag + "-" + nextJob.NumNodes + "n-" + nextJob.CorePerNode + "c-result.zip"; azureStorage.UploadBlob(blobName, runner.GetResultFilePath()); azureStorage.WriteLog("Job " + nextJob.RowKey + " finished"); pipeFactory.Close(); } catch (Exception ex) { azureStorage.WriteLog("Job " + nextJob.RowKey + " failed "); azureStorage.WriteLog(ex.ToString()); } //set job to finished this.azureStorage.SetJobState(nextJob.RowKey, true, blobName != null ? blobName.ToString() : string.Empty); }
public static void CustomChannel_Sync_Open_Close_Methods_Called() { MockChannelFactory <IRequestChannel> mockChannelFactory = null; MockRequestChannel mockRequestChannel = null; List <string> channelOpenMethodsCalled = new List <string>(); List <string> channelCloseMethodsCalled = new List <string>(); List <string> factoryOpenMethodsCalled = new List <string>(); List <string> factoryCloseMethodsCalled = new List <string>(); string testMessageBody = "CustomChannelTest_Sync"; Message inputMessage = Message.CreateMessage(MessageVersion.Default, action: "Test", body: testMessageBody); // *** SETUP *** \\ // Intercept the creation of the factory so we can intercept creation of the channel Func <Type, BindingContext, IChannelFactory> buildFactoryAction = (Type type, BindingContext context) => { // Create the channel factory and intercept all open and close method calls mockChannelFactory = new MockChannelFactory <IRequestChannel>(context, new TextMessageEncodingBindingElement().CreateMessageEncoderFactory()); MockCommunicationObject.InterceptAllOpenMethods(mockChannelFactory, factoryOpenMethodsCalled); MockCommunicationObject.InterceptAllCloseMethods(mockChannelFactory, factoryCloseMethodsCalled); // Override the OnCreateChannel call so we get the mock channel created by the factory mockChannelFactory.OnCreateChannelOverride = (EndpointAddress endpoint, Uri via) => { // Create the mock channel and intercept all its open and close method calls mockRequestChannel = (MockRequestChannel)mockChannelFactory.DefaultOnCreateChannel(endpoint, via); MockCommunicationObject.InterceptAllOpenMethods(mockRequestChannel, channelOpenMethodsCalled); MockCommunicationObject.InterceptAllCloseMethods(mockRequestChannel, channelCloseMethodsCalled); return(mockRequestChannel); }; return(mockChannelFactory); }; MockTransportBindingElement mockBindingElement = new MockTransportBindingElement(); mockBindingElement.BuildChannelFactoryOverride = buildFactoryAction; CustomBinding binding = new CustomBinding(mockBindingElement); EndpointAddress address = new EndpointAddress("myprotocol://localhost:5000"); var factory = new ChannelFactory <ICustomChannelServiceInterface>(binding, address); // We rely on the implicit open of the channel to be synchronous. // This is true for both the full framework and this NET Core version. ICustomChannelServiceInterface channel = factory.CreateChannel(); // *** EXECUTE *** \\ Message outputMessage = channel.Process(inputMessage); // The mock's default behavior is just to loopback what we sent. var result = outputMessage.GetBody <string>(); // Explicitly close the channel factory synchronously. // One of the important aspects of this test is that a synchronous // close of the factory also synchronously closes the channel. factory.Close(); // *** VALIDATE *** \\ Assert.True(String.Equals(testMessageBody, result), String.Format("Expected body to be '{0}' but actual was '{1}'", testMessageBody, result)); string expectedOpens = "OnOpening,OnOpen,OnOpened"; string expectedCloses = "OnClosing,OnClose,OnClosed"; string actualOpens = String.Join(",", channelOpenMethodsCalled); Assert.True(String.Equals(expectedOpens, actualOpens, StringComparison.Ordinal), String.Format("Expected channel open methods to be '{0}' but actual was '{1}'.", expectedOpens, actualOpens)); string actualCloses = String.Join(",", channelCloseMethodsCalled); Assert.True(String.Equals(expectedCloses, actualCloses, StringComparison.Ordinal), String.Format("Expected channel close methods to be '{0}' but actual was '{1}'.", expectedCloses, actualCloses)); actualOpens = String.Join(",", factoryOpenMethodsCalled); Assert.True(String.Equals(expectedOpens, actualOpens, StringComparison.Ordinal), String.Format("Expected factory open methods to be '{0}' but actual was '{1}'.", expectedOpens, actualOpens)); actualCloses = String.Join(",", factoryCloseMethodsCalled); Assert.True(String.Equals(expectedCloses, actualCloses, StringComparison.Ordinal), String.Format("Expected factory close methods to be '{0}' but actual was '{1}'.", expectedCloses, actualCloses)); Assert.True(factory.State == CommunicationState.Closed, String.Format("Expected factory's final state to be Closed but was '{0}'", factory.State)); Assert.True(((ICommunicationObject)channel).State == CommunicationState.Closed, String.Format("Expected channel's final state to be Closed but was '{0}'", ((ICommunicationObject)channel).State)); }
/// <summary> /// Close the instance for Coupon Managment channel Factory /// </summary> public void CouponManegmentServiceInstanceClosed() { _channelFactoryCouponManagment.Close(); }
public static void Certificate_With_CanonicalName_Fqdn_Address_EchoString() { bool shouldCallSucceed = false; var domainNameEndpointUri = new Uri(Endpoints.Tcp_ClientCredentialType_Certificate_With_CanonicalName_DomainName_Address); // Get just the hostname part of the domainName Uri var domainNameHost = domainNameEndpointUri.Host.Split('.')[0]; var fqdnEndpointUri = new Uri(Endpoints.Tcp_ClientCredentialType_Certificate_With_CanonicalName_Fqdn_Address); var endpointAddress = new EndpointAddress(fqdnEndpointUri); // If the WCF service's reported FQDN is the same as the services's reported hostname, // it means that there the WCF service is set up on a network where FQDNs aren't used, only hostnames. // Since our pass/fail detection logic on whether or not this is an FQDN depends on whether the host name has a '.', we don't test this case if (string.Compare(domainNameHost, fqdnEndpointUri.Host, StringComparison.OrdinalIgnoreCase) != 0) { shouldCallSucceed = fqdnEndpointUri.Host.IndexOf('.') > -1; } string testString = "Hello"; ChannelFactory <IWcfService> factory = null; IWcfService serviceProxy = null; try { // *** SETUP *** \\ NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport); binding.Security.Transport.ClientCredentialType = TcpClientCredentialType.None; factory = new ChannelFactory <IWcfService>(binding, endpointAddress); factory.Credentials.ServiceCertificate.Authentication.RevocationMode = X509RevocationMode.NoCheck; factory.Credentials.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.ChainTrust; serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ string result = serviceProxy.Echo(testString); // *** VALIDATE *** \\ Assert.Equal(testString, result); // *** CLEANUP *** \\ ((ICommunicationObject)serviceProxy).Close(); factory.Close(); var errorBuilder = new StringBuilder(); errorBuilder.AppendFormat("The call to '{0}' should have failed but succeeded. ", fqdnEndpointUri.Host); errorBuilder.AppendFormat("This means that the certificate validation passed when it should have failed. "); errorBuilder.AppendFormat("Check the certificate returned by the endpoint at '{0}' ", fqdnEndpointUri); errorBuilder.AppendFormat("to see that it is correct; if it is, there is likely an issue with the identity checking logic."); Assert.True(shouldCallSucceed, errorBuilder.ToString()); } catch (MessageSecurityException exception) { // If there's a MessageSecurityException, we assume that the cert validation failed. Unfortunately checking for the // message is really brittle and we can't account for loc and how .NET Native will display the exceptions // The exception message should look like: // // System.ServiceModel.Security.MessageSecurityException : Identity check failed for outgoing message. The expected // DNS identity of the remote endpoint was 'localhost' but the remote endpoint provided DNS claim 'example.com'.If this // is a legitimate remote endpoint, you can fix the problem by explicitly specifying DNS identity 'example.com' as // the Identity property of EndpointAddress when creating channel proxy. var errorBuilder = new StringBuilder(); errorBuilder.AppendFormat("The call to '{0}' should have been successful but failed with a MessageSecurityException. ", fqdnEndpointUri.Host); errorBuilder.AppendFormat("This usually means that the certificate validation failed when it should have passed. "); errorBuilder.AppendFormat("When connecting to host '{0}', the expectation is that the DNSClaim will be for the same hostname. ", fqdnEndpointUri.Host); errorBuilder.AppendFormat("Exception message: {0}{1}", Environment.NewLine, exception.Message); Assert.True(!shouldCallSucceed, errorBuilder.ToString()); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
/// <summary> /// Close the instance for Company Factory /// </summary> public void CompanyServiceInstanceClosed() { _channelFactoryCompany.Close(); }
public static void Certificate_With_CanonicalName_Localhost_Address_EchoString() { var localhostEndpointUri = new Uri(Endpoints.Tcp_ClientCredentialType_Certificate_With_CanonicalName_Localhost_Address); var endpointAddress = new EndpointAddress(localhostEndpointUri); bool shouldCallSucceed = string.Compare(localhostEndpointUri.Host, "localhost", StringComparison.OrdinalIgnoreCase) == 0; string testString = "Hello"; ChannelFactory <IWcfService> factory = null; IWcfService serviceProxy = null; try { // *** SETUP *** \\ NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport); binding.Security.Transport.ClientCredentialType = TcpClientCredentialType.None; factory = new ChannelFactory <IWcfService>(binding, endpointAddress); factory.Credentials.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.ChainTrust; serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ string result = serviceProxy.Echo(testString); // *** VALIDATE *** \\ Assert.Equal(testString, result); // *** CLEANUP *** \\ ((ICommunicationObject)serviceProxy).Close(); factory.Close(); var errorBuilder = new StringBuilder(); errorBuilder.AppendFormat("The call to '{0}' should have failed but succeeded. ", localhostEndpointUri.Host); errorBuilder.AppendFormat("This means that the certificate validation passed when it should have failed. "); errorBuilder.AppendFormat("Check the certificate returned by the endpoint at '{0}' ", localhostEndpointUri); errorBuilder.AppendFormat("to see that it is correct; if it is, there is likely an issue with the identity checking logic."); Assert.True(shouldCallSucceed, errorBuilder.ToString()); } catch (Exception exception) when(exception is CommunicationException || exception is MessageSecurityException) { if ((exception is MessageSecurityException) || (exception is CommunicationException) && !string.Equals(exception.InnerException.GetType().ToString(), "System.ServiceModel.Security.MessageSecurityException")) { // If there's a MessageSecurityException, we assume that the cert validation failed. Unfortunately checking for the // message is really brittle and we can't account for loc and how .NET Native will display the exceptions // The exception message should look like: // // System.ServiceModel.Security.MessageSecurityException : Identity check failed for outgoing message. The expected // DNS identity of the remote endpoint was 'localhost' but the remote endpoint provided DNS claim 'example.com'.If this // is a legitimate remote endpoint, you can fix the problem by explicitly specifying DNS identity 'example.com' as // the Identity property of EndpointAddress when creating channel proxy. var errorBuilder = new StringBuilder(); errorBuilder.AppendFormat("The call to '{0}' should have been successful but failed with a MessageSecurityException. ", localhostEndpointUri.Host); errorBuilder.AppendFormat("This usually means that the certificate validation failed when it should have passed. "); errorBuilder.AppendFormat("When connecting to host '{0}', the expectation is that the DNSClaim will be for the same hostname. ", localhostEndpointUri.Host); errorBuilder.AppendFormat("Exception message: {0}{1}", Environment.NewLine, exception.Message); Assert.True(!shouldCallSucceed, errorBuilder.ToString()); } } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
/// <summary> /// Close the instance for OpeningStock Factory /// </summary> public void ProductServiceInstanceClosed() { _channelFactoryProduct.Close(); }
//----< closes the send channel >-------------------------------- public void Close() { ChannelFactory <ICommunicator> temp = (ChannelFactory <ICommunicator>)channel; temp.Close(); }
static void Main() { // Create the custom binding and an endpoint address for the service. Binding multipleTokensBinding = BindingHelper.CreateMultiFactorAuthenticationBinding(); EndpointAddress serviceAddress = new EndpointAddress("http://localhost/servicemodelsamples/service.svc"); ChannelFactory <IEchoService> channelFactory = null; IEchoService client = null; Console.WriteLine("Username authentication required."); Console.WriteLine("Provide a valid machine or domain account. [domain\\user]"); Console.WriteLine(" Enter username:"******" Enter password:"******""; ConsoleKeyInfo info = Console.ReadKey(true); while (info.Key != ConsoleKey.Enter) { if (info.Key != ConsoleKey.Backspace) { if (info.KeyChar != '\0') { password += info.KeyChar; } info = Console.ReadKey(true); } else if (info.Key == ConsoleKey.Backspace) { if (password != "") { password = password.Substring(0, password.Length - 1); } info = Console.ReadKey(true); } } for (int i = 0; i < password.Length; i++) { Console.Write("*"); } Console.WriteLine(); try { // Create a proxy with the previously create binding and endpoint address channelFactory = new ChannelFactory <IEchoService>(multipleTokensBinding, serviceAddress); // configure the username credentials, the client certificate and the server certificate on the channel factory channelFactory.Credentials.UserName.UserName = username; channelFactory.Credentials.UserName.Password = password; channelFactory.Credentials.ClientCertificate.SetCertificate("CN=client.com", StoreLocation.CurrentUser, StoreName.My); channelFactory.Credentials.ServiceCertificate.SetDefaultCertificate("CN=localhost", StoreLocation.LocalMachine, StoreName.My); client = channelFactory.CreateChannel(); Console.WriteLine("Echo service returned: {0}", client.Echo()); ((IChannel)client).Close(); channelFactory.Close(); } catch (CommunicationException e) { Abort((IChannel)client, channelFactory); // if there is a fault then print it out FaultException fe = null; Exception tmp = e; while (tmp != null) { fe = tmp as FaultException; if (fe != null) { break; } tmp = tmp.InnerException; } if (fe != null) { Console.WriteLine("The server sent back a fault: {0}", fe.CreateMessageFault().Reason.GetMatchingTranslation().Text); } else { Console.WriteLine("The request failed with exception: {0}", e); } } catch (TimeoutException) { Abort((IChannel)client, channelFactory); Console.WriteLine("The request timed out"); } catch (Exception e) { Abort((IChannel)client, channelFactory); Console.WriteLine("The request failed with unexpected exception: {0}", e); } Console.WriteLine(); Console.WriteLine("Press <ENTER> to terminate client."); Console.ReadLine(); }
public static void ServiceRestart_Throws_CommunicationException() { // This test validates that if the Service were to shut-down, re-start or otherwise die in the // middle of an operation the client will not just hang. It should instead receive a CommunicationException. string restartServiceAddress = ""; ChannelFactory <IWcfService> setupHostFactory = null; IWcfService setupHostServiceProxy = null; ChannelFactory <IWcfRestartService> factory = null; IWcfRestartService serviceProxy = null; BasicHttpBinding binding = new BasicHttpBinding(); // *** Step 1 *** \\ // We need the Service to create and open a ServiceHost and then give us the endpoint address for it. try { setupHostFactory = new ChannelFactory <IWcfService>(binding, new EndpointAddress(Endpoints.HttpBaseAddress_Basic)); setupHostServiceProxy = setupHostFactory.CreateChannel(); restartServiceAddress = setupHostServiceProxy.GetRestartServiceEndpoint(); // *** CLEANUP *** \\ ((ICommunicationObject)setupHostServiceProxy).Close(); setupHostFactory.Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)setupHostServiceProxy, setupHostFactory); } // *** Additional Setup *** \\ // The restartServiceAddress we got from the Service used localhost as the host name. // We need the actual host name for the client call to work. // To make it easier to parse, localhost was replaced with '[HOST]'. // Use Endpoints.HttpBaseAddress_Basic only for the purpose of extracting the Service host name. // Then update 'restartServiceAddress' with it. string hostName = new Uri(Endpoints.HttpBaseAddress_Basic).Host; restartServiceAddress = restartServiceAddress.Replace("[HOST]", hostName); // Get the last portion of the restart service url which is a Guid and convert it back to a Guid // This is needed by the RestartService operation as a Dictionary key to get the ServiceHost string uniqueIdentifier = restartServiceAddress.Substring(restartServiceAddress.LastIndexOf("/") + 1); Guid guid = new Guid(uniqueIdentifier); // *** Step 2 *** \\ // Simple echo call to make sure the newly created endpoint is working. try { factory = new ChannelFactory <IWcfRestartService>(binding, new EndpointAddress(restartServiceAddress)); serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ string result = serviceProxy.NonRestartService(guid); Assert.True(result == "Success!", string.Format("Test Case failed, expected the returned string to be: {0}, instead it was: {1}", "Success!", result)); } catch (Exception ex) { string exceptionMessage = ex.Message; string innerExceptionMessage = ex.InnerException?.Message; string testExceptionMessage = $"The ping to validate the newly created endpoint failed.\nThe endpoint pinged was: {restartServiceAddress}\nThe GUID used to extract the ServiceHost from the server side dictionary was: {guid}"; string fullExceptionMessage = $"testExceptionMessage: {testExceptionMessage}\nexceptionMessage: {exceptionMessage}\ninnerExceptionMessage: {innerExceptionMessage}"; Assert.True(false, fullExceptionMessage); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } // *** Step 3 *** \\ // The actual part of the test where the host is killed in the middle of the operation. // We expect the test should not hang and should receive a CommunicationException. CommunicationException exception = Assert.Throws <CommunicationException>(() => { factory = new ChannelFactory <IWcfRestartService>(binding, new EndpointAddress(restartServiceAddress)); serviceProxy = factory.CreateChannel(); try { // *** EXECUTE *** \\ serviceProxy.RestartService(guid); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }); }