private static void Abort(IChannel channel, ChannelFactory channelFactory) { if (channel != null) channel.Abort(); if (channelFactory != null) channelFactory.Abort(); }
public void Abort() { IChannel channel = (IChannel)_channel; if (channel != null) { channel.Abort(); } if (!_channelFactoryRefReleased) { lock (s_staticLock) { if (!_channelFactoryRefReleased) { if (_channelFactoryRef.Release()) { _releasedLastRef = true; } _channelFactoryRefReleased = true; } } } // Abort the ChannelFactory if we released the last one. We should be able to abort it when another thread is closing it. if (_releasedLastRef) { _channelFactoryRef.Abort(); } }
private void OnOperationFailure(SecuritySessionOperation operation, EndpointAddress target, SecurityToken currentToken, Exception e, IChannel channel) { if (channel != null) { channel.Abort(); } }
public void Dispose() { if (_blnDisposed == false) { lock (_objSyncObject) { if (_objProxy != null) { IChannel objChannel = _objProxy as IChannel; if (objChannel != null) { if (objChannel.State == CommunicationState.Opened) { objChannel.Close(); } else if (objChannel.State == CommunicationState.Faulted) { objChannel.Abort(); objChannel.Close(); } objChannel.Faulted -= new EventHandler(Channel_Faulted); objChannel = null; } } if ((_objProxy != null) && (_objProxy is IDisposable)) { ((IDisposable)_objProxy).Dispose(); _objProxy = null; } } } }
/// <summary> /// ExecuteOnChannel method implementation /// </summary> private void ExecuteOnSpecificChannel(string operationName, string uri, ExecuteOptions options, CodeToRunOnChannel codeBlock) { using (new SPMonitoredScope("ExecuteSpecificChannel:" + operationName)) { try { string ep = FindLoadBalancerEndPoint(uri); if (!string.IsNullOrEmpty(ep)) { Uri xu = new Uri(ep); IChannel channel = (IChannel)GetChannel(xu, options); try { codeBlock((IIdentityServiceContract)channel); channel.Close(); } finally { if (channel.State != CommunicationState.Closed) { channel.Abort(); } } } } finally { } } }
private bool disposedValue = false; // To detect redundant calls protected virtual void Dispose(bool disposing) { if (!disposedValue) { if (disposing) { // TODO: dispose managed state (managed objects). if (Channel != null) { try { Channel.Close(); } catch (Exception) { Channel.Abort(); } (Channel as IDisposable).Dispose(); Channel = null; } } // TODO: free unmanaged resources (unmanaged objects) and override a finalizer below. // TODO: set large fields to null. disposedValue = true; } }
public void Abort() { IChannel channel = (IChannel)this.channel; if (channel != null) { channel.Abort(); } if (!this.channelFactoryRefReleased) { lock (ClientBase <TChannel> .staticLock) { if (!this.channelFactoryRefReleased) { if (this.channelFactoryRef.Release()) { this.releasedLastRef = true; } this.channelFactoryRefReleased = true; } } } if (this.releasedLastRef) { this.channelFactoryRef.Abort(); } }
async Task CloseChannelAsync(IChannel channel, CancellationToken token) { try { if (channel.State != CommunicationState.Closing && channel.State != CommunicationState.Closed) { CloseChannelState state = new CloseChannelState(this, channel); if (channel is ISessionChannel <IDuplexSession> ) { IDuplexSession duplexSession = ((ISessionChannel <IDuplexSession>)channel).Session; await duplexSession.CloseOutputSessionAsync(token); } else { await channel.CloseAsync(token); } } } catch (Exception e) { if (Fx.IsFatal(e)) { throw; } HandleError(e); if (channel is ISessionChannel <IDuplexSession> ) { channel.Abort(); } } }
static void Abort(IChannel channel, ChannelFactory cf) { if (channel != null) channel.Abort(); if (cf != null) cf.Abort(); }
protected override void OnAbort() { channel.Abort(); if (factory != null) // ... is it valid? { factory.Abort(); } }
protected override void OnAbort() { channel.Abort(); if (factory != null) { factory.Abort(); } }
void OnOperationFailure(SecuritySessionOperation operation, EndpointAddress target, SecurityToken currentToken, Exception e, IChannel channel) { SecurityTraceRecordHelper.TraceSecuritySessionOperationFailure(operation, target, currentToken, e); if (channel != null) { channel.Abort(); } }
/// <summary> /// ExecuteOnChannel method implementation /// </summary> private void ExecuteOnChannel(string operationName, ExecuteOptions options, CodeToRunOnChannel codeBlock) { using (new SPMonitoredScope("ExecuteOnChannel:" + operationName)) { bool mustexit = false; string firstaddress = ""; do { SPServiceLoadBalancerContext loadBalancerContext = m_LoadBalancer.BeginOperation(); try { if (firstaddress.Equals(loadBalancerContext.EndpointAddress.ToString())) { mustexit = true; } if (!mustexit) { if ((loadBalancerContext.Status == SPServiceLoadBalancerStatus.Succeeded)) { if (string.IsNullOrEmpty(firstaddress)) { firstaddress = loadBalancerContext.EndpointAddress.ToString(); } IChannel channel = (IChannel)GetChannel(loadBalancerContext.EndpointAddress, options); try { codeBlock((IIdentityServiceContract)channel); channel.Close(); mustexit = true; } catch (TimeoutException) { loadBalancerContext.Status = SPServiceLoadBalancerStatus.Failed; } catch (EndpointNotFoundException) { loadBalancerContext.Status = SPServiceLoadBalancerStatus.Failed; } finally { if (channel.State != CommunicationState.Closed) { channel.Abort(); } } } } } finally { loadBalancerContext.EndOperation(); } }while (!mustexit); } }
public void Abort() { IChannel channel = (IChannel)_channel; if (channel != null) { channel.Abort(); } ChannelFactory.Abort(); }
static void Abort(IChannel channel, ChannelFactory cf) { if (channel != null) { channel.Abort(); } if (cf != null) { cf.Abort(); } }
private static void Abort(IChannel channel, ChannelFactory channelFactory) { if (channel != null) { channel.Abort(); } if (channelFactory != null) { channelFactory.Abort(); } }
private void Cleanup(IChannel rstChannel, T negotiationState) { if (negotiationState != null) { negotiationState.Dispose(); } if (rstChannel != null) { rstChannel.Abort(); } }
protected override void OnAbort() { if (security_initiator != null) { security_initiator.Release(); } else { security_recipient.Release(); } channel.Abort(); }
/// <summary> /// Closes the given channel. /// </summary> /// <param name="athenaChannel">The channel to be close.</param> private void CloseChannel(IAthenaWcfService athenaChannel) { IChannel ch = athenaChannel as IChannel; try { ch.Close(m_CommunicationTimeout); } catch (TimeoutException) { ch.Abort(); } }
public void Abort() { lock (_objSyncObject) { if (_objProxy != null) { IChannel objChannel = _objProxy as IChannel; if (objChannel != null) { objChannel.Abort(); } } } }
private void Proxy_Faulted(object sender, EventArgs e) { //EFaulted(); workTimer.Stop(); IChannel channel = sender as IChannel; if (channel != null) { channel.Abort(); channel.Close(); } AbortProxy(true); }
void ICommunicationObject_Faulted(object sender, System.EventArgs e) { DefaultLogger.DUPLEXLogger.Error("context_Faulted"); this.OnInstanceContextFaulted(e); if (_Timer != null) { _Timer.Dispose(); } IChannel channel = sender as IChannel; if (channel != null) { channel.Abort(); channel.Close(); } DoWorkRoutine(cToken); }
public void Dispose() { IChannel connection = null; try { connection = (IChannel)Channel; connection.Close(); } catch (Exception) { if (connection != null) { connection.Abort(); } } }
public void AddIncomingChannel(IChannel channel) { bool added = false; lock (ThisLock) { if (State == LifetimeState.Opened) { if (_firstIncomingChannel == null) { if (_incomingChannels == null) { _firstIncomingChannel = channel; ChannelAdded(channel); } else { if (_incomingChannels.Contains(channel)) { return; } _incomingChannels.Add(channel); } } else { EnsureIncomingChannelCollection(); if (_incomingChannels.Contains(channel)) { return; } _incomingChannels.Add(channel); } added = true; } } if (!added) { channel.Abort(); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ObjectDisposedException(GetType().ToString())); } }
public void AddIncomingChannel(IChannel channel) { bool flag = false; lock (base.ThisLock) { if (base.State == LifetimeState.Opened) { if (this.firstIncomingChannel == null) { if (this.incomingChannels == null) { this.firstIncomingChannel = channel; this.ChannelAdded(channel); } else { if (this.incomingChannels.Contains(channel)) { return; } this.incomingChannels.Add(channel); } } else { this.EnsureIncomingChannelCollection(); if (this.incomingChannels.Contains(channel)) { return; } this.incomingChannels.Add(channel); } flag = true; } } if (!flag) { channel.Abort(); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ObjectDisposedException(base.GetType().ToString())); } }
protected override void OnAbort() { IChannel channel = null; lock (ThisLock) { channel = (channelsList.Count > 0) ? channelsList[channelsList.Count - 1] : null; } while (channel != null) { channel.Abort(); lock (ThisLock) { channelsList.Remove(channel); channel = (channelsList.Count > 0) ? channelsList[channelsList.Count - 1] : null; } } }
private static void CloseChannel(IChannel channel) { try { if (channel != null) { if (channel.State == CommunicationState.Faulted) { channel.Abort(); } else { channel.Close(); } } } catch (Exception ex) { Debug.WriteLine("Something blew up when closing a channel: {0}", ex.Message); } }
/// <summary> /// Fecha um wcf channel associado a uma instancia de servico /// </summary> /// <param name="servico">instancia de um objeto criado anteriormente com Ativador.Get()</param> public static void AbortChannel(object servico) { try { if (servico == null) { logger.Error("Erro em Ativador.AbortChannel(): Parametro nao pode ser nulo"); return; } IDuplexChannel channel2 = servico as IDuplexChannel; if (channel2 != null) { logger.Info("Abort duplex channel for: " + servico.ToString()); channel2.Close(); } else { IChannel channel = servico as IChannel; if (channel != null) { logger.Info("Abort channel for: " + servico.ToString()); try { channel.Close(); } catch (Exception ex) { logger.Error("Erro em Ativador.AbortChannel()" + ex.Message, ex); logger.Error("Trying really abort the channel"); channel.Abort(); } } } } catch (Exception ex) { logger.Error("Erro em Ativador.AbortChannel()" + ex.Message, ex); } }
private void CloseChannel(IChannel channel, TimeSpan timeout) { try { if (channel.State != CommunicationState.Closing && channel.State != CommunicationState.Closed) { CloseChannelState state = new CloseChannelState(this, channel); if (channel is ISessionChannel <IDuplexSession> ) { IDuplexSession duplexSession = ((ISessionChannel <IDuplexSession>)channel).Session; IAsyncResult result = duplexSession.BeginCloseOutputSession(timeout, Fx.ThunkCallback(new AsyncCallback(CloseOutputSessionCallback)), state); if (result.CompletedSynchronously) { duplexSession.EndCloseOutputSession(result); } } else { IAsyncResult result = channel.BeginClose(timeout, Fx.ThunkCallback(new AsyncCallback(CloseChannelCallback)), state); if (result.CompletedSynchronously) { channel.EndClose(result); } } } } catch (Exception e) { if (Fx.IsFatal(e)) { throw; } this.HandleError(e); if (channel is ISessionChannel <IDuplexSession> ) { channel.Abort(); } } }
protected override void OnAbort() { IChannel item = null; lock (base.ThisLock) { item = (this.channelsList.Count > 0) ? this.channelsList[this.channelsList.Count - 1] : null; goto Label_00A5; } Label_0049: item.Abort(); lock (base.ThisLock) { this.channelsList.Remove(item); item = (this.channelsList.Count > 0) ? this.channelsList[this.channelsList.Count - 1] : null; } Label_00A5: if (item != null) { goto Label_0049; } }
private void EnsureChannelIsAvailable() { if (ShouldCreateChannel) { lock (m_Lock) { if (ShouldCreateChannel) { if (m_Channel != null) { // The channel is probably faulted so terminate it. m_Diagnostics.Log( LevelToLog.Info, CommunicationConstants.DefaultLogTextPrefix, string.Format( CultureInfo.InvariantCulture, "Data channel for endpoint at {0} has faulted. Aborting channel.", m_Factory.Endpoint.Address.Uri)); m_Channel.Abort(); m_Service.Faulted -= HandleOnChannelFaulting; } m_Diagnostics.Log( LevelToLog.Info, CommunicationConstants.DefaultLogTextPrefix, string.Format( CultureInfo.InvariantCulture, "Creating data channel for endpoint at {0}.", m_Factory.Endpoint.Address.Uri)); m_WasFaulted = false; m_Service = m_Factory.CreateChannel(); m_Channel = m_Service; m_Service.Faulted += HandleOnChannelFaulting; } } } }
private void ExecuteOnChannel(string operationName, CodeToRunOnChannel codeBlock) { SPServiceLoadBalancerContext loadBalancerContext = _loadBalancer.BeginOperation(); try { // get a channel to the service app endpoint IChannel channel = (IChannel)GetChannel(loadBalancerContext.EndpointAddress); try { // execute the code block codeBlock((IDayNamerContract)channel); channel.Close(); } catch (TimeoutException) { loadBalancerContext.Status = SPServiceLoadBalancerStatus.Failed; throw; } catch (EndpointNotFoundException) { loadBalancerContext.Status = SPServiceLoadBalancerStatus.Failed; throw; } finally { if (channel.State != CommunicationState.Closed) { channel.Abort(); } } } finally { loadBalancerContext.EndOperation(); } }
private void CloseChannel(IChannel channel, TimeSpan timeout) { try { if ((channel.State != CommunicationState.Closing) && (channel.State != CommunicationState.Closed)) { CloseChannelState state = new CloseChannelState(this, channel); if (channel is ISessionChannel<IDuplexSession>) { IDuplexSession session = ((ISessionChannel<IDuplexSession>) channel).Session; IAsyncResult result = session.BeginCloseOutputSession(timeout, Fx.ThunkCallback(new AsyncCallback(ListenerHandler.CloseOutputSessionCallback)), state); if (result.CompletedSynchronously) { session.EndCloseOutputSession(result); } } else { IAsyncResult result2 = channel.BeginClose(timeout, Fx.ThunkCallback(new AsyncCallback(ListenerHandler.CloseChannelCallback)), state); if (result2.CompletedSynchronously) { channel.EndClose(result2); } } } } catch (Exception exception) { if (Fx.IsFatal(exception)) { throw; } this.HandleError(exception); if (channel is ISessionChannel<IDuplexSession>) { channel.Abort(); } } }