/// <summary>
/// 客户端连入事件函数
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void AcceptedEventHandler(object sender, SocketAsyncEventArgs e)
{
Socket listenSocket = (Socket)sender;
SocketAsyncEventArgs acceptArgs = new SocketAsyncEventArgs();
acceptArgs.Completed += AcceptedEventHandler;
try
{
if (!listenSocket.AcceptAsync(acceptArgs))
{
AcceptedEventHandler(listenSocket, acceptArgs);
}
LogPool.Logger.LogInformation((int)LogEvent.套接字, $"accepted { e.AcceptSocket.Handle} {(IPEndPoint)e.AcceptSocket.LocalEndPoint} {(IPEndPoint)e.AcceptSocket.RemoteEndPoint}");
}
catch (ObjectDisposedException)
{
return;
}
SocketChannel channel = new SocketChannel(
e.AcceptSocket,
SocketType.Accept,
(IPEndPoint)e.AcceptSocket.LocalEndPoint,
(IPEndPoint)e.AcceptSocket.RemoteEndPoint,
_handler);
channel.Received += Received;
Accepted?.Invoke(this, new AcceptedEventArgs
{
Socket = e.AcceptSocket,
Channel = channel
});
}
private void OnAccepted(Accepted accepted)
{
LearnerState state = learnerState.GetOrAdd(accepted.ProposalNumber, new LearnerState
{
BallotNumber = accepted.BallotNumber,
NumberOfAccepts = 1,
ProposalNumber = accepted.ProposalNumber
});
if (state.BallotNumber < accepted.BallotNumber)
{
return;
}
if (state.Accepted) // duplicate
{
return;
}
state.NumberOfAccepts += 1;
if (state.NumberOfAccepts < acceptors.Length / 2)
{
return;
}
OnAcceptedValue(accepted.Value);
}
internal void OnAccepted(WebSocketSession session)
{
Accepted?.Invoke(this, new WebSocketServerAcceptedArgs()
{
Session = session
});
}
private void Confirmer_tresor_Click(object sender, RoutedEventArgs e)
{
double value, value0 = 0;
if (Tresor_Annee.Text == "" || !double.TryParse(Tresor_Annee.Text, out value))
{
NotAccepted.Visibility = Visibility.Visible;
DoubleAnimation a = new DoubleAnimation();
a.From = 1.0;
a.To = 0.0;
a.Duration = new Duration(TimeSpan.FromSeconds(5));
NotAccepted.BeginAnimation(OpacityProperty, a);
}
else
{
double.TryParse(Tresor_Annee.Text, out value0);
double value1 = value0 + responsable.tresor;
responsable.tresor = value1;
responsable.nouveau_tresor(value1);
Accepted.Visibility = Visibility.Visible;
DoubleAnimation a = new DoubleAnimation();
a.From = 1.0;
a.To = 0.0;
a.Duration = new Duration(TimeSpan.FromSeconds(5));
Accepted.BeginAnimation(OpacityProperty, a);
Grid_Principale.Visibility = Visibility.Visible;
Grid_Principale.IsEnabled = true;
Ajouter_Montant_Tresor.Visibility = Visibility.Hidden;
Ajouter_Montant_Tresor.IsEnabled = false;
}
}
public virtual string GetProperty(string strPropertyName, string strFormat, System.Globalization.CultureInfo formatProvider, DotNetNuke.Entities.Users.UserInfo accessingUser, DotNetNuke.Services.Tokens.Scope accessLevel, ref bool propertyNotFound)
{
switch (strPropertyName.ToLower())
{
case "rideid": // Int
return(RideId.ToString(strFormat, formatProvider));
case "userid": // Int
return(UserId.ToString(strFormat, formatProvider));
case "accepted": // Bit
return(Accepted.ToString());
case "comments": // NVarCharMax
if (Comments == null)
{
return("");
}
;
return(PropertyAccess.FormatString(Comments, strFormat));
default:
propertyNotFound = true;
break;
}
return(Null.NullString);
}
static AmqpConstants()
{
AmqpConstants.BatchedMessageFormat = "com.microsoft:batched-message-format";
AmqpConstants.SimpleWebTokenPropertyName = "com.microsoft:swt";
AmqpConstants.ContainerId = "container-id";
AmqpConstants.ConnectionId = "connection-id";
AmqpConstants.LinkName = "link-name";
AmqpConstants.ClientMaxFrameSize = "client-max-frame-size";
AmqpConstants.HostName = "hostname";
AmqpConstants.NetworkHost = "network-host";
AmqpConstants.Port = "port";
AmqpConstants.Address = "address";
AmqpConstants.PublisherId = "publisher-id";
AmqpConstants.NullBinary = new ArraySegment <byte>();
AmqpConstants.EmptyBinary = new ArraySegment <byte>(new byte[0]);
AmqpConstants.DefaultProtocolVersion = new AmqpVersion(1, 0, 0);
DateTime dateTime = DateTime.Parse("1970-01-01T00:00:00.0000000Z", CultureInfo.InvariantCulture);
AmqpConstants.StartOfEpoch = dateTime.ToUniversalTime();
DateTime maxValue = DateTime.MaxValue;
AmqpConstants.MaxAbsoluteExpiryTime = maxValue.ToUniversalTime() - TimeSpan.FromDays(1);
AmqpConstants.AcceptedOutcome = new Accepted();
AmqpConstants.ReleasedOutcome = new Released();
AmqpConstants.RejectedOutcome = new Rejected();
AmqpConstants.RejectedNotFoundOutcome = new Rejected()
{
Error = AmqpError.NotFound
};
}
public void Should_advance_it_to_a_valid_state_with_that_value()
{
Guid serviceId = Guid.NewGuid();
Learner<string> learner = new Learner<string>(serviceId)
{
Bus = MockRepository.GenerateMock<IServiceBus>()
};
Accepted<string> message = new Accepted<string>
{
BallotId = 1,
CorrelationId = serviceId,
IsFinal = false,
Value = "Chris",
ValueBallotId = 1,
};
learner.RaiseEvent(Learner<string>.ValueAccepted, message);
learner.CurrentState.ShouldEqual(Learner<string>.Active);
learner.Value.ShouldEqual(message.Value);
learner.BallotId.ShouldEqual(message.BallotId);
}
private void DeleteMenuButton_Click(object sender, RoutedEventArgs e)
{
Accepted selectedItem = (Accepted)AcceptedDataGrid.SelectedItem;
if (selectedItem == null)
{
MessageBox.Show("Line not selected");
return;
}
try
{
if (_db.Storage.FirstOrDefault(o => o.NameItem == selectedItem.NameItem) != null)
{
Accepted acceptedObj = _db.Accepted.FirstOrDefault(o => o.NameItem == selectedItem.NameItem);
Models.Storage storageObj = _db.Storage.FirstOrDefault(o => o.NameItem == selectedItem.NameItem);
if (acceptedObj == null || storageObj == null)
{
throw new ArgumentNullException();
}
_db.Accepted.Remove(acceptedObj);
_db.Storage.Remove(storageObj);
Refresh();
}
else
{
MessageBox.Show("Already sold. Unable to delete");
}
}
catch (Exception)
{
MessageBox.Show("Error");
}
}
async Task Listen()
{
while (true)
{
var listener = _listener;
TcpClient client = null;
try
{
if (_listener == null)
{
return;
}
client = await listener.AcceptTcpClientAsync();
}
catch (ObjectDisposedException)
{
return;
}
if (_listener == null)
{
return;
}
var channel = new TcpChannel(client);
Accepted?.Invoke(this, channel);
}
}
public override int GetHashCode()
{
int hash = 1;
if (TradeId.Length != 0)
{
hash ^= TradeId.GetHashCode();
}
if (OtherPartyUuid.Length != 0)
{
hash ^= OtherPartyUuid.GetHashCode();
}
hash ^= items_.GetHashCode();
hash ^= otherPartyItems_.GetHashCode();
if (Accepted != false)
{
hash ^= Accepted.GetHashCode();
}
if (OtherPartyAccepted != false)
{
hash ^= OtherPartyAccepted.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
static void DispatchRequest(ListenerLink link, Message message, DeliveryState deliveryState, object state)
{
RequestProcessor thisPtr = (RequestProcessor)state;
ListenerLink responseLink = null;
if (message.Properties != null || message.Properties.ReplyTo != null)
{
thisPtr.responseLinks.TryGetValue(message.Properties.ReplyTo, out responseLink);
}
Outcome outcome;
if (responseLink == null)
{
outcome = new Rejected()
{
Error = new Error()
{
Condition = ErrorCode.NotFound,
Description = "Not response link was found. Ensure the link is attached or reply-to is set on the request."
}
};
}
else
{
outcome = new Accepted();
}
link.DisposeMessage(message, outcome, true);
RequestContext context = new RequestContext(link, responseLink, message);
thisPtr.processor.Process(context);
}
protected void AcceptConnection(IAsyncResult result)
{
try
{
Accepted.Set();
Socket listener, handler;
if (result == null ||
(listener = result.AsyncState as Socket) == null ||
(handler = listener.EndAccept(result)) == null)
{
return;
}
// TODO: Consider making this configurable.
const int bufferSize = 1024;
// Begin receiving.
var state = new TransmissionState(this, bufferSize, handler, ServiceValues.EoF);
state.Receive();
}
catch (ObjectDisposedException)
{
// Exit gracefully in the event of a shutdown.
}
catch (Exception e)
{
ErrorOut(e);
}
}
/// <summary>
/// Can be used to create filtering of new connections.
/// </summary>
/// <param name="socket">Accepted socket</param>
/// <returns>true if connection can be accepted; otherwise false.</returns>
protected bool OnAcceptingSocket(Socket socket)
{
ClientAcceptedEventArgs args = new ClientAcceptedEventArgs(socket);
Accepted?.Invoke(this, args);
return(!args.Revoked);
}
private void EndAcceptTcpClient(IAsyncResult state)
{
var listener = state.AsyncState as TcpListener;
if (listener == null)
{
return;
}
bool needAccept = true;
try
{
var client = listener.EndAcceptTcpClient(state);
var channel = new TcpChannel(client);
Accepted?.Invoke(this, channel);
}
catch (SocketException)
{
needAccept = true;
}
catch (ObjectDisposedException)
{
needAccept = false;
return;
}
finally
{
if (needAccept)
{
listener.BeginAcceptTcpClient(EndAcceptTcpClient, listener);
}
}
}
public override int GetHashCode()
{
int hash = 1;
if (SessionId.Length != 0)
{
hash ^= SessionId.GetHashCode();
}
if (Uuid.Length != 0)
{
hash ^= Uuid.GetHashCode();
}
if (TradeId.Length != 0)
{
hash ^= TradeId.GetHashCode();
}
if (Accepted != false)
{
hash ^= Accepted.GetHashCode();
}
if (OtherPartyAccepted != false)
{
hash ^= OtherPartyAccepted.GetHashCode();
}
if (Cancelled != false)
{
hash ^= Cancelled.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
protected override Result PerformServiceLoop()
{
Accepted.Reset();
ConnectionSocket.BeginAccept(AcceptConnection, ConnectionSocket);
Accepted.WaitOne();
return(Result.Success);
}
internal void OnAccepted(WebSocketSession session, System.Action callBack)
{
Accepted?.Invoke(this, new WebSocketServerAcceptedArgs()
{
Session = session,
Call = callBack,
});
}
protected virtual void OnAccept()
{
Raise(() => {
Handlers?.Accept(new HandleContext {
Session = this
});
Accepted?.Invoke(this, EventArgs.Empty);
});
}
public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
{
// Arrange
var result = new Accepted <object>("location", null);
HttpContext httpContext = null;
// Act & Assert
Assert.ThrowsAsync <ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
}
public async Task <ISocket> AcceptAsync()
{
var socket = await _socket.AcceptAsync();
var wrapper = new SocketTesterWrapper(socket, "accepted");
Accepted?.Invoke(wrapper);
return(wrapper);
}
public ActionResult AcceptProduct(int Id)
{
Accepted accepted = db.Accepteds.Where(a => a.IdProduct == Id).FirstOrDefault();
accepted.Verified = true;
db.SaveChanges();
//System.Diagnostics.Debug.WriteLine("Am gasit"); ////
return(Redirect("/Products/Index"));
}
public void Remove(long studentId, long courseId) => Locker.RunWriteAction(() =>
{
Logger.LogRemoveStarted();
if (!Accepted.ContainsKey(studentId))
{
Logger.LogRemoveFinished();
return;
}
Accepted[studentId]?.Remove(courseId);
Logger.LogRemoveFinished();
});
protected virtual void AcceptComplete(object sender, IOTaskCompleteEventArgs <SocketAcceptTask> e)
{
if (e.Task.Exception == null)
{
Accepted?.Invoke(this, new AcceptEventArgs(new AresTcpSocket(Formatter, e.Task.AcceptSocket)));
}
if (Socket != null)
{
Socket.QueueAccept(e.Task);
}
}
public void AcceptedResult_ProblemDetails_SetsStatusCodeAndValue()
{
// Arrange & Act
var expectedUrl = "testAction";
var obj = new HttpValidationProblemDetails();
var result = new Accepted <HttpValidationProblemDetails>(expectedUrl, obj);
// Assert
Assert.Equal(StatusCodes.Status202Accepted, result.StatusCode);
Assert.Equal(StatusCodes.Status202Accepted, obj.Status);
Assert.Equal(obj, result.Value);
}
public bool Contains(long studentId, long courseId) => Locker.RunReadAction(() =>
{
Logger.LogQueryStarted();
if (!Accepted.ContainsKey(studentId))
{
Logger.LogQueryFinished();
return(false);
}
bool result = Accepted[studentId]?.Contains(courseId) ?? false;
Logger.LogQueryFinished();
return(result);
});
public TestChannelPair ImmitateAccept(TestChannel incomeChannel)
{
if (!IsListening)
{
throw new InvalidOperationException();
}
var thisChannel = new TestChannel();
var pair = TntTestHelper.CreateChannelPair(thisChannel, incomeChannel);
pair.ConnectAndStartReceiving();
Accepted?.Invoke(this, thisChannel);
return(pair);
}
void OnMessage(AmqpMessage message)
{
Outcome outcome;
if (message.ValueBody.Value is Declare)
{
int txnId = this.CreateTransaction();
outcome = new Declared()
{
TxnId = new ArraySegment <byte>(BitConverter.GetBytes(txnId))
};
}
else if (message.ValueBody.Value is Discharge)
{
Discharge discharge = (Discharge)message.ValueBody.Value;
int txnId = BitConverter.ToInt32(discharge.TxnId.Array, discharge.TxnId.Offset);
Transaction txn;
if (this.transactions.TryGetValue(txnId, out txn))
{
lock (this.transactions)
{
this.transactions.Remove(txnId);
}
txn.Discharge(discharge.Fail ?? false);
outcome = new Accepted();
}
else
{
outcome = new Rejected()
{
Error = new Error()
{
Condition = AmqpErrorCode.NotFound
}
};
}
}
else
{
outcome = new Rejected()
{
Error = new Error()
{
Condition = AmqpErrorCode.NotAllowed
}
};
}
message.Link.DisposeDelivery(message, true, outcome);
}
public async Task ExecuteAsync_SetsStatusCodeAndLocationHeader()
{
// Arrange
var expectedUrl = "testAction";
var httpContext = GetHttpContext();
// Act
var result = new Accepted(expectedUrl);
await result.ExecuteAsync(httpContext);
// Assert
Assert.Equal(StatusCodes.Status202Accepted, httpContext.Response.StatusCode);
Assert.Equal(expectedUrl, httpContext.Response.Headers["Location"]);
}
private async Task ListenContinuouslyAsync()
{
while (Listening)
{
var client = await TcpListener.AcceptTcpClientAsync().ConfigureAwait(false);
Task.Run(() =>
{
var endPoint = (IPEndPoint)client.Client.RemoteEndPoint;
var eventArgs = new Connection(endPoint.Address, endPoint.Port, ConnectionOptions, new TcpClientAdapter(client));
Accepted?.Invoke(this, eventArgs);
}).Forget();
}
}
/// <summary>
/// To service model
/// </summary>
/// <returns></returns>
public CertificateRequestRecordModel ToServiceModel()
{
return(new CertificateRequestRecordModel {
RequestId = RequestId,
EntityId = EntityId,
Type = Type,
State = State,
GroupId = GroupId,
Submitted = Submitted?.ToServiceModel(),
Accepted = Accepted?.ToServiceModel(),
Approved = Approved?.ToServiceModel(),
ErrorInfo = ErrorInfo
});
}
public override void DispatchMessage(Message result)
{
if (result.GetType().Name.ToString() == "Accepted")
{
Accepted accepted = (Accepted)result;
this.ProposalNumber.Add(accepted.ProposalNumber);
this.Values.Add(accepted.AcceptedValue);
this.knownAcceptors.Add(result.Originator);
if (this.knownAcceptors.Count > acceptorsCount / 2)
{
AcceptedConfirm = true;
}
Console.WriteLine("Accepted Value: {0}", AppliedValue());
}
}
static void OnMessage(ListenerLink link, Message message, DeliveryState deliveryState, object state)
{
var thisPtr = (Publisher)state;
string errorCondition = null;
if (message.ApplicationProperties != null &&
(errorCondition = (string)message.ApplicationProperties["errorcondition"]) != null)
{
link.DisposeMessage(
message,
new Rejected() { Error = new Error() { Condition = errorCondition, Description = "message was rejected" } },
true);
}
else
{
var txnState = deliveryState as TransactionalState;
if (txnState != null)
{
Transaction txn = thisPtr.queue.broker.txnManager.GetTransaction(txnState.TxnId);
txn.AddOperation(message, onDischarge, thisPtr);
txnState.Outcome = new Accepted();
}
else
{
thisPtr.queue.Enqueue((BrokerMessage)message);
deliveryState = new Accepted();
}
thisPtr.link.DisposeMessage(message, deliveryState, true);
}
}
