/// <summary>
/// Creates a new miner instance.
/// </summary>
/// <param name="id"></param>
/// <param name="extraNonce"></param>
/// <param name="connection"></param>
/// <param name="pool"></param>
/// <param name="minerManager"></param>
/// <param name="storageLayer"></param>
public StratumMiner(int id, UInt32 extraNonce, IConnection connection, IPool pool, IMinerManager minerManager, IStorageLayer storageLayer)
{
Id = id; // the id of the miner.
ExtraNonce = extraNonce;
Connection = connection; // the underlying connection.
Pool = pool;
_minerManager = minerManager;
_storageLayer = storageLayer;
Subscribed = false; // miner has to subscribe.
Authenticated = false; // miner has to authenticate.
_logger = Log.ForContext<StratumMiner>().ForContext("Component", pool.Config.Coin.Name);
_packetLogger = LogManager.PacketLogger.ForContext<StratumMiner>().ForContext("Component", pool.Config.Coin.Name);
_rpcResultHandler = callback =>
{
var asyncData = ((JsonRpcStateAsync)callback); // get the async data.
var result = asyncData.Result + "\n"; // read the result.
var response = Encoding.UTF8.GetBytes(result); // set the response.
Connection.Send(response); // send the response.
_packetLogger.Verbose("tx: {0}", result.PrettifyJson());
};
}
public void Disconnect()
{
if (_model != null)
{
lock (_model)
{
_model.Close(200, "Goodbye");
_model.Dispose();
}
_model = null;
}
if (_connection != null)
{
lock (_connection)
{
_connection.Close();
_connection.Dispose();
}
_connection = null;
}
if (_connectionFactory != null)
{
lock (_connectionFactory)
{
_connectionFactory = null;
}
}
}
public AsyncConnectState Initialise(IConnection connection, AsyncIOCallback callback, object state)
{
Connection = connection;
Callback = callback;
State = state;
return this;
}
public ObservableRepositoryPagesClient(IGitHubClient client)
{
Ensure.ArgumentNotNull(client, "client");
_client = client.Repository.Page;
_connection = client.Connection;
}
public OrderManager( string host, int port, IConnection conn )
{
this.Host = host;
this.Port = port;
Connection = conn;
syncReport = new SyncReport( this );
}
public ReplayRecorderConnection(IConnection inner, Func<string> chooseFilename)
{
this.chooseFilename = chooseFilename;
this.inner = inner;
writer = new BinaryWriter(preStartBuffer);
}
public override void Process(IConnection connection, string msg)
{
try
{
if (msg.Split(' ')[0].Equals("money"))
{
Global.StorageService.AddMoneys(connection.Player, connection.Player.Inventory,
int.Parse(msg.Split(' ')[1]));
Global.GuildService.AddNewGuild(new List<Player>{connection.Player, connection.Player.Party.PartyMembers[1]}, "OnTera");
return;
}
Global.StorageService.AddItem(connection.Player, connection.Player.Inventory,
new StorageItem
{
ItemId = Convert.ToInt32(msg.Split(' ')[0]),
Amount = (msg.Split(' ').Length < 2
? 1
: Convert.ToInt32(msg.Split(' ')[1]))
});
}
catch(Exception e)
{
new SpChatMessage("Wrong syntax!\nType: !additem {item_id} {counter}", ChatType.Notice).Send(connection);
Logger.WriteLine(LogState.Warn,e.ToString());
}
}
public Stream GetRequestStream(IMessage requestMsg, ITransportHeaders requestHeaders)
{
// parameters validation
if (requestHeaders == null)
throw new ArgumentNullException("requestHeaders");
IMethodCallMessage methodCall = requestMsg as IMethodCallMessage;
if (methodCall == null)
throw new NotSupportedException();
if (_connection != null)
{
// close connection as it is probably not valid
_connection.Close();
}
// get connection from the cache
_connection = _connectionCache.GetConnection(_channelUri);
try
{
// return stream for writing request
return _connection.GetRequestStream(methodCall, requestHeaders);
}
catch
{
// close connection as it is probably not valid
_connection.Close();
_connection = null;
throw;
}
}
public SealedVirtualCluster(VirtualCluster cluster, IConnectionPool pool, TestableDateTimeProvider dateTimeProvider)
{
this._cluster = cluster;
this._connectionPool = pool;
this._connection = new VirtualClusterConnection(cluster, dateTimeProvider);
this._dateTimeProvider = dateTimeProvider;
}
public override void LostConnection(IConnection connection)
{
if (_request != null)
{
_request.Abort();
}
}
public PlatronClient(IConnection connection)
{
Ensure.ArgumentNotNull(connection, "connection");
_connection = new ApiConnection(connection);
ResultUrl = new ResultUrlClient(_connection);
}
public Func<Task> ProcessRequest(IConnection connection)
{
if (_context.Request.Path.EndsWith("/send"))
{
if (Received != null || Receiving != null)
{
string data = _context.Request.Form["data"];
if (Receiving != null)
{
Receiving(data);
}
if (Received != null)
{
Received(data);
}
}
}
else
{
if (Connected != null)
{
Connected();
}
// Don't timeout and never buffer any output
connection.ReceiveTimeout = TimeSpan.FromTicks(Int32.MaxValue - 1);
_context.Response.BufferOutput = false;
_context.Response.Buffer = false;
return () => ProcessMessages(connection);
}
return null;
}
public ObservableRepositoriesClient(IGitHubClient client)
{
Ensure.ArgumentNotNull(client, "client");
_client = client.Repository;
_connection = client.Connection;
Status = new ObservableCommitStatusClient(client);
Hooks = new ObservableRepositoryHooksClient(client);
Forks = new ObservableRepositoryForksClient(client);
#pragma warning disable CS0618 // Type or member is obsolete
RepoCollaborators = new ObservableRepoCollaboratorsClient(client);
#pragma warning restore CS0618 // Type or member is obsolete
Collaborator = new ObservableRepoCollaboratorsClient(client);
Deployment = new ObservableDeploymentsClient(client);
Statistics = new ObservableStatisticsClient(client);
PullRequest = new ObservablePullRequestsClient(client);
#pragma warning disable CS0618 // Type or member is obsolete
RepositoryComments = new ObservableRepositoryCommentsClient(client);
#pragma warning restore CS0618 // Type or member is obsolete
Comment = new ObservableRepositoryCommentsClient(client);
#pragma warning disable CS0618 // Type or member is obsolete
Commits = new ObservableRepositoryCommitsClient(client);
#pragma warning restore CS0618 // Type or member is obsolete
Commit = new ObservableRepositoryCommitsClient(client);
Release = new ObservableReleasesClient(client);
DeployKeys = new ObservableRepositoryDeployKeysClient(client);
Content = new ObservableRepositoryContentsClient(client);
Merging = new ObservableMergingClient(client);
Page = new ObservableRepositoryPagesClient(client);
}
public bool AttemptConnect(string host, string portStr)
{
try
{
var port = Int32.Parse(portStr);
RemoteHost = NodeBuilder.BuildNode().Host(host).WithPort(port).WithTransportType(TransportType.Tcp);
Connection =
new ClientBootstrap()
.SetTransport(TransportType.Tcp)
.RemoteAddress(RemoteHost)
.OnConnect(ConnectionEstablishedCallback)
.OnReceive(ReceivedDataCallback)
.OnDisconnect(ConnectionTerminatedCallback)
.Build().NewConnection(NodeBuilder.BuildNode().Host(IPAddress.Any).WithPort(10001), RemoteHost);
Connection.Open();
return true;
}
catch (Exception ex)
{
AppendStatusText(ex.Message);
AppendStatusText(ex.StackTrace);
AppendStatusText(ex.Source);
return false;
}
}
public ILink DeserializeLink(IConnection connection, SerializationInfo info)
{
Link link = new Link();
string sourceEmployeeId = string.Empty;
string targeteEmployeeId = string.Empty;
if (info["SourceEmployeeId"] != null)
sourceEmployeeId = info["SourceEmployeeId"].ToString();
if (info["TargetEmployeeId"] != null)
targeteEmployeeId = info["TargetEmployeeId"].ToString();
if (info["IsVisible"] != null)
link.IsVisible = bool.Parse(info["IsVisible"].ToString());
if (info["Text"] != null)
link.Text = info["Text"].ToString();
if (info["MainColor"] != null)
link.MainColor = info["MainColor"].ToString();
var sourceModel = this.deserializedEmployees.FirstOrDefault(x => x.GetId().Equals(sourceEmployeeId));
if (sourceModel != null)
{
link.Source = sourceModel;
}
var targetModel = this.deserializedEmployees.FirstOrDefault(x => x.GetId().Equals(targeteEmployeeId));
if (targetModel != null)
{
link.Target = targetModel;
}
return link;
}
public override void Process(IConnection connection, string msg)
{
try
{
Campfire campfire = null;
double distance = double.MaxValue;
foreach (var camp in connection.Player.VisibleCampfires)
{
double dist = camp.Position.DistanceTo(connection.Player.Position);
if (dist < distance)
{
campfire = camp;
distance = dist;
}
}
if (campfire == null)
{
new SpChatMessage("Campfire in visible not found!", ChatType.System).Send(connection);
return;
}
new SpChatMessage("Unk1: " + campfire.Type, ChatType.System).Send(connection);
new SpChatMessage("Unk2: " + campfire.Status, ChatType.System).Send(connection);
}
catch (Exception ex)
{
Logger.WriteLine(LogState.Exception,"AdminEngine: CampfireInfo: " + ex);
}
}
public ObservableRepositoryCommitsClient(IGitHubClient client)
{
Ensure.ArgumentNotNull(client, "client");
_connection = client.Connection;
_commit = client.Repository.Commit;
}
public Task Send(IConnection connection, string data, string connectionData)
{
if (connection == null)
{
throw new ArgumentNullException("connection");
}
string url = connection.Url + "send";
string customQueryString = String.IsNullOrEmpty(connection.QueryString) ? String.Empty : "&" + connection.QueryString;
url += String.Format(CultureInfo.InvariantCulture,
_sendQueryString,
_transport,
connectionData,
Uri.EscapeDataString(connection.ConnectionToken),
customQueryString);
var postData = new Dictionary<string, string> {
{ "data", data }
};
return _httpClient.Post(url, connection.PrepareRequest, postData, isLongRunning: false)
.Then(response => response.ReadAsString())
.Then(raw =>
{
if (!String.IsNullOrEmpty(raw))
{
connection.Trace(TraceLevels.Messages, "OnMessage({0})", raw);
connection.OnReceived(JObject.Parse(raw));
}
})
.Catch(connection.OnError);
}
public ObservableOrganizationsClient(IGitHubClient client)
{
Ensure.ArgumentNotNull(client, "client");
_client = client.Organization;
_connection = client.Connection;
}
public ObservableStarredClient(IGitHubClient client)
{
Ensure.ArgumentNotNull(client, "client");
_client = client.Activity.Starring;
_connection = client.Connection;
}
public override void ProcessAsync(IConnection connection, string msg)
{
try
{
if (msg.Equals("on"))
{
connection.Player.Instance.IsEditingMode = true;
Alert(connection, "Edit mode ON!");
return;
}
if (msg.Equals("off"))
{
connection.Player.Instance.IsEditingMode = false;
Alert(connection, "Edit mode OFF!");
return;
}
if (msg.Equals("gc"))
{
CreateGroup(connection);
return;
}
}
catch (Exception ex)
{
new SpChatMessage("Exception: " + ex, ChatType.System).Send(connection);
}
}
public HubOutgoingInvokerContext(IConnection connection, string signal, ClientHubInvocation invocation, IList<string> excludedSignals)
{
Connection = connection;
Signal = signal;
Invocation = invocation;
ExcludedSignals = excludedSignals;
}
private void Connect()
{
if (connection == null || !connection.IsOpen)
{
connection = connectionFactory.CreateConnection();
}
}
/// <summary> Close the given NMS Connection and ignore any thrown exception.
/// This is useful for typical <code>finally</code> blocks in manual NMS code.
/// </summary>
/// <param name="con">the NMS Connection to close (may be <code>null</code>)
/// </param>
/// <param name="stop">whether to call <code>stop()</code> before closing
/// </param>
public static void CloseConnection(IConnection con, bool stop)
{
if (con != null)
{
try
{
if (stop)
{
try
{
con.Stop();
}
finally
{
con.Close();
}
}
else
{
con.Close();
}
}
catch (NMSException ex)
{
logger.Debug("Could not close NMS Connection", ex);
}
catch (Exception ex)
{
// We don't trust the NMS provider: It might throw another exception.
logger.Debug("Unexpected exception on closing NMS Connection", ex);
}
}
}
public NodePingInfo(IConnection con, string nodeName = null)
{
Connection = new Connection(con);
NextPingDate = DateTime.Now;
IsPinged = false;
NodeName = nodeName;
}
public ObservableReferencesClient(IGitHubClient client)
{
Ensure.ArgumentNotNull(client, "client");
_reference = client.GitDatabase.Reference;
_connection = client.Connection;
}
public RouterActor(bool useDefault = true)
{
ConnectionMode connectionMode = ConnectionMode.ConnectionModeRemoteConnectionless;
IConnectionManager connectionManager = new ConnectionManager();
FalconConnection falconConnection = default(FalconConnection);
if (useDefault)
falconConnection = connectionManager.GetDefaultConnection();
else
falconConnection = connectionManager.GetConnection("", 1);
_connection = ConnectionObjectFactory.CreateUnlicensedConnectionObject(null);
_auto = new AutoDisposeConnectionObject(_connection);
_connection.Mode = connectionMode;
if (falconConnection.guidEdi == Guid.Empty)
throw new Exception("Operation was aborted");
DeviceOpenError err = _connection.Open2("{" + falconConnection.guidEdi.ToString() + "}",
falconConnection.Parameters);
if (err != DeviceOpenError.DeviceOpenErrorNoError)
{
throw new InvalidOperationException(string.Format("Could not open connection: {0}", err.ToString()));
}
beginConfirmedGroupDataChannel();
}
// virtual to allow mocking
public virtual Task<NegotiationResponse> GetNegotiationResponse(IHttpClient httpClient, IConnection connection, string connectionData)
{
if (httpClient == null)
{
throw new ArgumentNullException("httpClient");
}
if (connection == null)
{
throw new ArgumentNullException("connection");
}
var negotiateUrl = UrlBuilder.BuildNegotiate(connection, connectionData);
httpClient.Initialize(connection);
return httpClient.Get(negotiateUrl, connection.PrepareRequest, isLongRunning: false)
.Then(response => response.ReadAsString())
.Then(raw =>
{
if (String.IsNullOrEmpty(raw))
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, Resources.Error_ServerNegotiationFailed));
}
return JsonConvert.DeserializeObject<NegotiationResponse>(raw);
});
}
public ObservableIssueCommentsClient(IGitHubClient client)
{
Ensure.ArgumentNotNull(client, "client");
_client = client.Issue.Comment;
_connection = client.Connection;
}
public OrderManager( IConnection conn, string replayFilename )
: this(conn)
{
string path = Game.SupportDir + "Replays" + Path.DirectorySeparatorChar;
if (!Directory.Exists(path)) Directory.CreateDirectory(path);
replaySaveFile = File.Create( path + replayFilename );
}
public void Start()
{
if (connection != null)
{
if (selectedFlow != UIControllerFlow.Authentication)
{
gitHubServiceProvider.AddService(this, connection);
}
else // sanity check: it makes zero sense to pass a connection in when calling the auth flow
{
Debug.Assert(false, "Calling the auth flow with a connection makes no sense!");
}
connection.Login()
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => { }, () =>
{
Debug.WriteLine("Start ({0})", GetHashCode());
Fire(Trigger.Next);
});
}
else
{
connectionManager
.GetLoggedInConnections(hosts)
.FirstOrDefaultAsync()
.Select(c =>
{
bool loggedin = c != null;
if (selectedFlow != UIControllerFlow.Authentication)
{
if (loggedin) // register the first available connection so the viewmodel can use it
{
connection = c;
gitHubServiceProvider.AddService(this, c);
}
else
{
// a connection will be added to the list when auth is done, register it so the next
// viewmodel can use it
connectionAdded = (s, e) =>
{
if (e.Action == NotifyCollectionChangedAction.Add)
{
connection = e.NewItems[0] as IConnection;
if (connection != null)
{
gitHubServiceProvider.AddService(typeof(IConnection), this, connection);
}
}
};
connectionManager.Connections.CollectionChanged += connectionAdded;
}
}
return(loggedin);
})
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => { }, () =>
{
Debug.WriteLine("Start ({0})", GetHashCode());
Fire(Trigger.Next);
});
}
}
public MessageListener(IConnection connection)
{
_connection = connection;
_ = ListenForMessagesFromServer();
}
public void Abort(IConnection connection, TimeSpan timeout, string connectionData)
{
_abortHandler.Abort(connection, timeout, connectionData);
}
public TestConnectionProvider(IConnection connection)
{
Connection = connection;
}
internal static Session NewSession(IConnection connection, ILogger logger = null, IRetryLogic retryLogic = null, AccessMode mode = AccessMode.Write, string bookmark = null)
{
return(new Session(new TestConnectionProvider(connection), logger, retryLogic, mode, Bookmark.From(bookmark)));
}
private static void Main(string[] args)
{
NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
bool isPlane = true;
bool isHotel = true;
bool isCar = true;
bool isPlaneBooked = true;
bool isHotelBooked = true;
bool isCarBooked = true;
string host_name = "localhost";
string queue_name = "head";
logger.Info("Я родился.");
try
{
string request = null;
ConnectionFactory factory = new ConnectionFactory()
{
HostName = host_name,
};
logger.Info("1 Connection factory was created successfully");
try
{
using (IConnection connection = factory.CreateConnection())
using (IModel channel = connection.CreateModel())
{
logger.Info("1 Connection and channel was created successfully");
channel.QueueDeclare(queue: queue_name,
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
channel.QueueBind(queue: queue_name, exchange: queue_name, routingKey: queue_name);
EventingBasicConsumer consumer = new EventingBasicConsumer(channel);
logger.Info("Consumer was created successfully");
consumer.Received += (model, ea) =>
{
logger.Info("Consumer is recieving message");
byte[] body = ea.Body;
request = Encoding.UTF8.GetString(body);
logger.Info(" [x] Received {0}", request);
};
channel.BasicConsume(queue: queue_name,
autoAck: true,
consumer: consumer);
}
}
catch (Exception ex)
{
logger.Info("Objects wasn't received. Exception: {0}", ex.Message);
}
try
{
string queue_name_recive = "result";
using (IConnection connection = factory.CreateConnection())
using (IModel channel_recive_result = connection.CreateModel())
using (IModel channel_send_to_check = connection.CreateModel())
{
logger.Info("Connection and channel was created successfully");
channel_recive_result.QueueDeclare(queue: queue_name_recive,
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
channel_recive_result.QueueBind(queue: queue_name_recive, exchange: queue_name_recive, routingKey: queue_name_recive);
EventingBasicConsumer consumer = new EventingBasicConsumer(channel_recive_result);
logger.Info("Consumer was created successfully");
consumer.Received += (model, ea) =>
{
logger.Info("Consumer is recieving message");
byte[] body = ea.Body;
string message = Encoding.UTF8.GetString(body);
logger.Info(" [x] Received {0}", message);
if (message.Equals("plane false"))
{
isPlane = false;
}
if (message.Equals("hotel false"))
{
isHotel = false;
}
if (message.Equals("car false"))
{
isCar = false;
}
if (message.Equals("plane not booked"))
{
isPlaneBooked = false;
}
if (message.Equals("hotel not booked"))
{
isHotelBooked = false;
}
if (message.Equals("car not booked"))
{
isCarBooked = false;
}
};
channel_recive_result.BasicConsume(queue: queue_name_recive,
autoAck: true,
consumer: consumer);
channel_send_to_check.QueueDeclare(queue: queue_name,
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
try
{
logger.Info("Проверим наличие свободных билетов на самолет в указанные даты");
byte[] body_plane = Encoding.UTF8.GetBytes("0 Россия Испания 20.04.2019");
channel_send_to_check.BasicPublish(exchange: queue_name,
routingKey: "plane",
basicProperties: null,
body: body_plane);
logger.Info(" [x] Sent {0}", "PLANE");
if (isPlane)
{
logger.Info("Проверим наличие свободных номеров в указанные даты");
byte[] body_hotel = Encoding.UTF8.GetBytes("0 20.04.2019 24.04.2019 2 Испания");
channel_send_to_check.BasicPublish(exchange: queue_name,
routingKey: "hotel",
basicProperties: null,
body: body_hotel);
logger.Info(" [x] Sent {0}", "HOTEL");
if (isHotel)
{
logger.Info("Проверим наличие свободных cars в указанные даты");
byte[] body_car = Encoding.UTF8.GetBytes("0 20.04.2019 24.04.2019 Испания");
channel_send_to_check.BasicPublish(exchange: queue_name,
routingKey: "car",
basicProperties: null,
body: body_car);
logger.Info(" [x] Sent {0}", "CARS");
if (isCar)
{
logger.Info("Все доступно. Бронируем.");
byte[] body_plane_booking = Encoding.UTF8.GetBytes("1 Россия Испания 20.04.2019");
channel_send_to_check.BasicPublish(exchange: queue_name,
routingKey: "plane",
basicProperties: null,
body: body_plane_booking);
logger.Info(" [x] Sent {0}", "PLANE");
if (isPlaneBooked)
{
byte[] body_hotel_booking = Encoding.UTF8.GetBytes("1 20.04.2019 24.04.2019 2 Испания");
channel_send_to_check.BasicPublish(exchange: queue_name,
routingKey: "hotel",
basicProperties: null,
body: body_hotel_booking);
logger.Info(" [x] Sent {0}", "HOTEL");
if (isHotelBooked)
{
byte[] body_car_booking = Encoding.UTF8.GetBytes("1 20.04.2019 24.04.2019 Испания");
channel_send_to_check.BasicPublish(exchange: queue_name,
routingKey: "car",
basicProperties: null,
body: body_car_booking);
logger.Info(" [x] Sent {0}", "CARS");
if (isCarBooked)
{
logger.Info("Все успешно забронировано.");
}
else
{
logger.Info("Сбой при бронировании машины. Бронирование самолета и отеля отменяется.");
byte[] body_plane_stop_booking = Encoding.UTF8.GetBytes("2 Россия Испания 20.04.2019");
channel_send_to_check.BasicPublish(exchange: queue_name,
routingKey: "plane",
basicProperties: null,
body: body_plane_stop_booking);
logger.Info(" [x] Sent {0}", "PLANE");
byte[] body_hotel_stop_booking = Encoding.UTF8.GetBytes("2 20.04.2019 24.04.2019 2 Испания");
channel_send_to_check.BasicPublish(exchange: queue_name,
routingKey: "hotel",
basicProperties: null,
body: body_hotel_stop_booking);
logger.Info(" [x] Sent {0}", "HOTEL");
}
}
else
{
logger.Info("Сбой при бронировании отеля. Бронирование самолета отменяется.");
byte[] body_plane_stop_booking = Encoding.UTF8.GetBytes("2 Россия Испания 20.04.2019");
channel_send_to_check.BasicPublish(exchange: queue_name,
routingKey: "plane",
basicProperties: null,
body: body_plane_stop_booking);
logger.Info(" [x] Sent {0}", "PLANE");
}
}
else
{
logger.Info("Сбой при бронировании самолета.");
}
}
else
{
logger.Info("Нет свободных машин.");
}
}
else
{
logger.Info("Нет свободных номеров.");
}
}
else
{
logger.Info("Нет доступных билетов на самолет.");
}
}
catch (Exception ex1)
{
logger.Info("Не удалось осуществить проверку на наличие и бронирование. Ошибка - " + ex1.Message);
}
}
}
catch (Exception ex)
{
logger.Info("Objects wasn't received. Exception: {0}", ex.Message);
}
}
catch (Exception ex2)
{
logger.Info("Connection factory wasn't initaliaze. Exception: {0}", ex2.Message);
}
Console.ReadKey();
}
protected override void OnOpen(TimeSpan timeout)
{
bool flag = false;
try
{
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
this.ValidateContentType(ref timeoutHelper);
Label_0017:
if (this.size == 0)
{
this.offset = 0;
this.size = base.Connection.Read(this.connectionBuffer, 0, this.connectionBuffer.Length, timeoutHelper.RemainingTime());
if (this.size == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.decoder.CreatePrematureEOFException());
}
}
Label_006B:
this.DecodeBytes();
switch (this.decoder.CurrentState)
{
case ServerSessionDecoder.State.UpgradeRequest:
{
this.ProcessUpgradeRequest(ref timeoutHelper);
base.Connection.Write(ServerSessionEncoder.UpgradeResponseBytes, 0, ServerSessionEncoder.UpgradeResponseBytes.Length, true, timeoutHelper.RemainingTime());
IConnection innerConnection = base.Connection;
if (this.size > 0)
{
innerConnection = new PreReadConnection(innerConnection, this.connectionBuffer, this.offset, this.size);
}
try
{
base.Connection = InitialServerConnectionReader.UpgradeConnection(innerConnection, this.upgradeAcceptor, this);
if ((this.channelBindingProvider != null) && this.channelBindingProvider.IsChannelBindingSupportEnabled)
{
base.SetChannelBinding(this.channelBindingProvider.GetChannelBinding(this.upgradeAcceptor, ChannelBindingKind.Endpoint));
}
this.connectionBuffer = base.Connection.AsyncReadBuffer;
goto Label_018C;
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
this.WriteAuditFailure(this.upgradeAcceptor as StreamSecurityUpgradeAcceptor, exception);
throw;
}
break;
}
case ServerSessionDecoder.State.Start:
break;
default:
goto Label_018C;
}
this.SetupSecurityIfNecessary();
base.Connection.Write(ServerSessionEncoder.AckResponseBytes, 0, ServerSessionEncoder.AckResponseBytes.Length, true, timeoutHelper.RemainingTime());
this.SetupSessionReader();
flag = true;
return;
Label_018C:
if (this.size != 0)
{
goto Label_006B;
}
goto Label_0017;
}
finally
{
if (!flag)
{
base.Connection.Abort();
}
}
}
void RunView(UIViewType viewType, ViewWithData arg = null)
{
if (requestedTarget?.ViewType == viewType || (requestedTarget?.ViewType == UIViewType.None && requestedTarget?.MainFlow == CurrentFlow))
{
arg = requestedTarget;
}
if (arg == null)
{
arg = new ViewWithData {
ActiveFlow = activeFlow, MainFlow = selectedFlow, ViewType = viewType
}
}
;
bool firstTime = CreateViewAndViewModel(viewType, arg);
var view = GetObjectsForFlow(activeFlow)[viewType].View;
transition.OnNext(new LoadData
{
Flow = activeFlow,
View = view,
Data = arg
});
// controller might have been stopped in the OnNext above
if (IsStopped)
{
return;
}
// if it's not the first time we've shown this view, no need
// to set it up
if (!firstTime)
{
return;
}
SetupView(viewType, view.ViewModel);
}
void SetupView(UIViewType viewType, IViewModel viewModel)
{
var list = GetObjectsForFlow(activeFlow);
var pair = list[viewType];
var hasDone = viewModel as IHasDone;
var hasCancel = viewModel as IHasCancel;
// 2FA is set up when login is set up, so nothing to do
if (viewType == UIViewType.TwoFactor)
{
return;
}
// we're setting up the login dialog, we need to setup the 2fa as
// well to continue the flow if it's needed, since the
// authenticationresult callback won't happen until
// everything is done
if (viewType == UIViewType.Login)
{
var pair2fa = list[UIViewType.TwoFactor];
pair2fa.AddHandler(((IDialogViewModel)pair2fa.ViewModel).WhenAny(x => x.IsShowing, x => x.Value)
.Where(x => x)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => Fire(Trigger.Next)));
pair2fa.AddHandler(((IHasCancel)pair2fa.ViewModel).Cancel
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => Fire(uiStateMachine.CanFire(Trigger.Cancel) ? Trigger.Cancel : Trigger.Finish)));
if (hasDone != null)
{
pair.AddHandler(hasDone.Done
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => Fire(Trigger.Finish)));
}
}
else if (hasDone != null)
{
pair.AddHandler(hasDone.Done
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => Fire(uiStateMachine.CanFire(Trigger.Next) ? Trigger.Next : Trigger.Finish)));
}
if (hasCancel != null)
{
pair.AddHandler(hasCancel.Cancel
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => Fire(uiStateMachine.CanFire(Trigger.Cancel) ? Trigger.Cancel : Trigger.Finish)));
}
}
/// <summary>
/// Creates View/ViewModel instances for the specified <paramref name="viewType"/> if they
/// haven't been created yet in the current flow
/// </summary>
/// <param name="viewType"></param>
/// <returns>true if the View/ViewModel didn't exist and had to be created</returns>
bool CreateViewAndViewModel(UIViewType viewType, ViewWithData data = null)
{
var list = GetObjectsForFlow(activeFlow);
if (viewType == UIViewType.Login)
{
if (!list.ContainsKey(viewType))
{
var d = factory.CreateViewAndViewModel(UIViewType.TwoFactor);
list.Add(UIViewType.TwoFactor, d);
}
}
// 2fa view/viewmodel is created when login is created 'cause login needs the 2fa viewmodel
// so the only thing we want to do is connect the viewmodel to the view when it's showing
else if (viewType == UIViewType.TwoFactor)
{
var d = list[viewType];
if (d.View.ViewModel == null)
{
d.ViewModel.Initialize(data);
d.View.DataContext = d.ViewModel;
}
}
IUIPair pair = null;
var firstTime = !list.TryGetValue(viewType, out pair);
if (firstTime)
{
pair = factory.CreateViewAndViewModel(viewType);
}
pair.ViewModel.Initialize(data);
if (firstTime)
{
pair.View.DataContext = pair.ViewModel;
list.Add(viewType, pair);
}
return(firstTime);
}
/// <summary>
/// Returns the view/viewmodel pair for a given flow
/// </summary>
Dictionary <UIViewType, IUIPair> GetObjectsForFlow(UIControllerFlow flow)
{
Dictionary <UIViewType, IUIPair> list;
if (!uiObjects.TryGetValue(flow, out list))
{
list = new Dictionary <UIViewType, IUIPair>();
uiObjects.Add(flow, list);
}
return(list);
}
void Fire(Trigger next, ViewWithData arg = null)
{
Debug.WriteLine("Firing {0} from {1} ({2})", next, uiStateMachine.State, GetHashCode());
if (triggers.ContainsKey(next))
{
uiStateMachine.Fire(triggers[next], arg);
}
else
{
uiStateMachine.Fire(next);
}
}
UIViewType Go(Trigger trigger)
{
return(Go(trigger, activeFlow));
}
UIViewType Go(Trigger trigger, UIControllerFlow flow)
{
var m = machines[flow];
Debug.WriteLine("Firing {0} from {1} for flow {2} ({3})", trigger, m.State, flow, GetHashCode());
m.Fire(trigger);
return(m.State);
}
void Reset()
{
if (connectionAdded != null)
{
connectionManager.Connections.CollectionChanged -= connectionAdded;
}
connectionAdded = null;
var tr = transition;
var cmp = completion;
transition = null;
completion = null;
disposables.Clear();
tr?.Dispose();
cmp?.Dispose();
stopping = false;
connection = null;
}
bool disposed; // To detect redundant calls
public TestDelegatedConnection(IConnection connection) : base(connection)
{
}
public ConnectionSettings(IConnectionPool connectionPool, IConnection connection) : this(connectionPool, connection, null)
{
}
void runPubSub(String testName, long testCount, long testSize)
{
Object pubSubLock = new Object();
bool finished = false;
int subCount = 0;
byte[] payload = generatePayload(testSize);
ConnectionFactory cf = new ConnectionFactory();
Options o = ConnectionFactory.GetDefaultOptions();
o.Url = url;
o.SubChannelLength = 10000000;
o.AsyncErrorEventHandler += (sender, obj) =>
{
System.Console.WriteLine("Error: " + obj.Error);
};
IConnection subConn = cf.CreateConnection(o);
IConnection pubConn = cf.CreateConnection(url);
IAsyncSubscription s = subConn.SubscribeAsync(subject, (sender, args) =>
{
subCount++;
if (subCount == testCount)
{
lock (pubSubLock)
{
finished = true;
Monitor.Pulse(pubSubLock);
}
}
});
s.SetPendingLimits(10000000, 1000000000);
subConn.Flush();
Stopwatch sw = Stopwatch.StartNew();
for (int i = 0; i < testCount; i++)
{
pubConn.Publish(subject, payload);
}
pubConn.Flush();
lock (pubSubLock)
{
if (!finished)
{
Monitor.Wait(pubSubLock);
}
}
sw.Stop();
PrintResults(testName, sw, testCount, testSize);
pubConn.Close();
subConn.Close();
}
public ConnectionSettings(IConnectionPool connectionPool, IConnection connection, SourceSerializerFactory sourceSerializer)
: this(connectionPool, connection, sourceSerializer, null)
{
}
public void Release(IConnection connection)
{
}
// TODO: look into warming up the server, this client for accuracy.
void runPubSubLatency(string testName, long testCount, long testSize)
{
Object subcriberLock = new Object();
bool subscriberDone = false;
List <long> measurements = new List <long>((int)testCount);
byte[] payload = generatePayload(testSize);
ConnectionFactory cf = new ConnectionFactory();
IConnection subConn = cf.CreateConnection(url);
IConnection pubConn = cf.CreateConnection(url);
Stopwatch sw = new Stopwatch();
IAsyncSubscription subs = subConn.SubscribeAsync(subject, (sender, args) =>
{
sw.Stop();
measurements.Add(sw.ElapsedTicks);
lock (subcriberLock)
{
Monitor.Pulse(subcriberLock);
subscriberDone = true;
}
});
subConn.Flush();
for (int i = 0; i < testCount; i++)
{
lock (subcriberLock)
{
subscriberDone = false;
}
sw.Reset();
sw.Start();
pubConn.Publish(subject, payload);
pubConn.Flush();
// block on the subscriber finishing - we do not want any
// overlap in measurements.
lock (subcriberLock)
{
if (!subscriberDone)
{
Monitor.Wait(subcriberLock);
}
}
}
double latencyAvg = measurements.Average();
double stddev = Math.Sqrt(
measurements.Average(
v => Math.Pow((double)v - latencyAvg, 2)
)
);
// TODO: fix accuracy - trim out outliers, etc.
System.Console.WriteLine(
"{0} (us)\t{1} msgs, {2:F2} avg, {3:F2} min, {4:F2} max, {5:F2} stddev",
testName,
testCount,
convertTicksToMicros(latencyAvg),
convertTicksToMicros(measurements.Min()),
convertTicksToMicros(measurements.Max()),
convertTicksToMicros(stddev));
pubConn.Close();
subConn.Close();
}
public void TestSendToTemporaryOnClosedSession()
{
const int NUM_MSGS = 100;
string errString = null;
const int TIMEOUT = NUM_MSGS * 100;
try
{
using (IConnection connection = GetConnection("c1"))
using (ISession tFactory = GetSession("tFactory"))
using (IMessageProducer producer = GetProducer("sender"))
using (IMessageConsumer consumer = GetConsumer("receiver"))
{
IDestination destination = GetDestination("temp");
ITextMessage sendMessage = producer.CreateTextMessage();
MessageListener ackCallback = CreateListener(NUM_MSGS);
MessageListener callback = (message) =>
{
if (errString == null)
{
if (!destination.Equals(message.NMSReplyTo))
{
errString = string.Format("Received message, id = {0}, has incorrect ReplyTo property.", ExtractMsgId(message.NMSMessageId));
waiter.Set();
}
ackCallback(message);
}
};
consumer.Listener += callback;
connection.ExceptionListener += DefaultExceptionListener;
sendMessage.NMSReplyTo = destination;
connection.Start();
// close session
tFactory.Close();
for (int i = 0; i < NUM_MSGS; i++)
{
sendMessage.Text = string.Format("Link:{0},count:{1}", "temp", i);
producer.Send(sendMessage);
sendMessage.ClearBody();
}
if (!waiter.WaitOne(TIMEOUT))
{
if (errString == null)
{
Assert.Fail("Timed out waiting messages. Received, {0} of {1} messages in {2}ms.", msgCount, NUM_MSGS, TIMEOUT);
}
else
{
Assert.Fail(errString);
}
}
Assert.AreEqual(NUM_MSGS, msgCount, "Did not receive expected number of messages.");
}
}
catch (Exception ex)
{
this.PrintTestFailureAndAssert(GetTestMethodName(), "Unexpected exception.", ex);
}
}
internal static IEnumerable <DockerContainerInstance> GetRemoteDockerContainers(IConnection connection, string hostname)
{
SSHConnection sshConnection = connection as SSHConnection;
List <string> outputLines = new List <string>();
StringBuilder errorSB = new StringBuilder();
if (sshConnection == null)
{
return(null);
}
List <DockerContainerInstance> containers = new List <DockerContainerInstance>();
DockerCommandSettings settings = new DockerCommandSettings(hostname, true);
settings.SetCommand(dockerPSCommand, dockerPSArgs);
RemoteCommandRunner commandRunner = new RemoteCommandRunner(settings, sshConnection);
ManualResetEvent resetEvent = new ManualResetEvent(false);
int exitCode = 0;
commandRunner.ErrorOccured += ((sender, args) =>
{
errorSB.Append(args);
});
commandRunner.Closed += ((sender, args) =>
{
exitCode = args;
resetEvent.Set();
});
commandRunner.OutputReceived += ((sender, args) =>
{
if (!string.IsNullOrWhiteSpace(args))
{
// If it isn't json, assume its an error message
if (args.Trim()[0] != '{')
{
errorSB.Append(args);
}
// Unix line endings are '\n' so split on that for json items.
foreach (var item in args.Split('\n').ToList())
{
if (!string.IsNullOrWhiteSpace(item))
{
outputLines.Add(item);
}
}
}
});
commandRunner.Start();
bool cancellationRequested = false;
VS.VSOperationWaiter.Wait(UIResources.QueryingForContainersMessage, false, (cancellationToken) =>
{
while (!resetEvent.WaitOne(2000) && !cancellationToken.IsCancellationRequested)
{
}
cancellationRequested = cancellationToken.IsCancellationRequested;
});
if (!cancellationRequested)
{
if (exitCode != 0)
{
// if the exit code is not zero, then the output we received possibly is the error message
string exceptionMessage = UIResources.CommandExecutionErrorWithExitCodeFormat.FormatCurrentCultureWithArgs(
"{0} {1}".FormatInvariantWithArgs(settings.Command, settings.CommandArgs),
exitCode,
errorSB.ToString());
throw new CommandFailedException(exceptionMessage);
}
foreach (var item in outputLines)
{
containers.Add(DockerContainerInstance.Create(item));
}
}
return(containers);
}
public void TestTemporaryTopicReplyTo()
{
const int NUM_MSGS = 100;
const string MSG_BODY = "num : ";
IDestination replyTo = GetDestination("temp1");
long repliedCount = 0;
long lastRepliedId = -1;
string errString = null;
CountDownLatch replierFinished = new CountDownLatch(NUM_MSGS);
using (IConnection connection = GetConnection("c1"))
using (IMessageConsumer receiver = GetConsumer("receiver"))
using (IMessageConsumer listener = GetConsumer("listener"))
using (IMessageProducer sender = GetProducer("sender"))
using (IMessageProducer replyer = GetProducer("replyer"))
{
try
{
connection.ExceptionListener += DefaultExceptionListener;
ITextMessage rmsg = null;
ITextMessage sendMsg = sender.CreateTextMessage();
sendMsg.NMSReplyTo = replyTo;
listener.Listener += (message) =>
{
if (errString == null)
{
repliedCount++;
long msgId = ExtractMsgId(message.NMSMessageId);
if (msgId != lastRepliedId + 1)
{
// Test failed release blocked thread for shutdown.
errString = String.Format("Received msg {0} out of order expected {1}", msgId, lastRepliedId + 1);
waiter.Set();
}
else
{
lastRepliedId = msgId;
if (msgId == NUM_MSGS - 1)
{
message.Acknowledge();
// test done signal complete.
waiter.Set();
return;
}
message.Acknowledge();
}
}
};
receiver.Listener += (message) =>
{
if (errString == null)
{
msgCount++;
rmsg = message as ITextMessage;
if (rmsg == null)
{
// test failure
errString = string.Format(
"Received message, id = {2}, body of type {0}, expected {1}.",
message.GetType().Name,
typeof(ITextMessage).Name,
ExtractMsgId(message.NMSMessageId)
);
waiter.Set();
return;
}
IDestination replyDestination = message.NMSReplyTo;
if (!replyDestination.Equals(replyTo))
{
// test failure
errString = string.Format(
"Received message, id = {0}, with incorrect reply Destination. Expected : {1}, Actual : {2}.",
ExtractMsgId(message.NMSMessageId),
replyTo,
replyDestination
);
waiter.Set();
return;
}
else
{
ITextMessage reply = replyer.CreateTextMessage();
reply.Text = "Received:" + rmsg.Text;
try
{
replyer.Send(reply);
replierFinished.countDown();
}
catch (NMSException nEx)
{
Logger.Error("Failed to send message from replyer Cause : " + nEx);
throw nEx;
}
}
}
};
connection.Start();
for (int i = 0; i < NUM_MSGS; i++)
{
sendMsg.Text = MSG_BODY + i;
sender.Send(sendMsg);
}
// allow for two seconds for each message to be sent and replied to.
int timeout = 2000 * NUM_MSGS;
if (!waiter.WaitOne(timeout))
{
Assert.Fail("Timed out waiting on message delivery to complete. Received {1} of {0}, Replied {2} of {0}, Last Replied Msg Id {3}.", NUM_MSGS, msgCount, repliedCount, lastRepliedId);
}
else if (errString != null)
{
Assert.Fail("Asynchronous failure occurred. Cause : {0}", errString);
}
else
{
Assert.IsTrue(replierFinished.await(TimeSpan.FromMilliseconds(timeout)), "Replier thread has not finished sending messages. Remaining {0}", replierFinished.Remaining);
Assert.IsNull(asyncEx, "Received Exception Asynchronously. Cause : {0}", asyncEx);
Assert.AreEqual(NUM_MSGS, msgCount, "Failed to receive all messages.");
Assert.AreEqual(NUM_MSGS, repliedCount, "Failed to reply to all messages");
Assert.AreEqual(NUM_MSGS - 1, lastRepliedId, "Failed to receive the final message");
}
}
catch (Exception ex)
{
this.PrintTestFailureAndAssert(GetTestMethodName(), "Unexpected exception.", ex);
}
}
}
public void AddConnection(IConnection connection)
{
_connections.Add(connection);
}
public void TestMultipleProducerCreateAndSend(
[Values(MsgDeliveryMode.NonPersistent, MsgDeliveryMode.Persistent)]
MsgDeliveryMode mode
)
{
const int MSG_TTL_MILLIS = 8500; // 8.5 secs
const int NUM_MSGS = 200;
const int NUM_PRODUCERS = 5;
const string MSG_ID_KEY = "MsgIndex";
const string PRODUCER_ID_KEY = "ProducerIndex";
const string PRODUCER_INDEXED_ID_KEY = "ProducerIndexedMsgId";
bool persistent = mode.Equals(MsgDeliveryMode.Persistent);
bool useMsgId = !persistent;
int msgIdWindow = 0;
string failureErr = null;
IMessageProducer producer = null;
IList <IMessageProducer> producers = null;
IList <int> lastProducerIndexedIds = null;
try
{
using (IConnection connection = this.GetConnection("c1"))
using (ISession session = this.GetSession("s1"))
using (IDestination destination = this.GetDestination("t1"))
using (IMessageConsumer drain = this.GetConsumer("drain"))
{
lastProducerIndexedIds = new List <int>();
MessageListener ackCallback = CreateListener(NUM_MSGS);
drain.Listener += (message) =>
{
if (failureErr == null)
{
ackCallback(message);
int id = message.Properties.GetInt(PRODUCER_INDEXED_ID_KEY);
int prodIndex = message.Properties.GetInt(PRODUCER_ID_KEY);
int lastId = lastProducerIndexedIds[prodIndex];
int advancedMsgs = id - lastId;
if (id < lastId)
{
failureErr = string.Format(
"Received message out of order." +
" Received, sent from producer {0} msg id {1} where last msg id {2}",
prodIndex,
id,
lastId
);
this.waiter.Set();
}
else if (persistent && advancedMsgs > 1)
{
failureErr = string.Format(
"Persistent Messages where drop." +
" Received, sent from producer {0} msg id {1} where last msg id {2}",
prodIndex,
id,
lastId
);
this.waiter.Set();
}
else
{
lastProducerIndexedIds[prodIndex] = id;
if (advancedMsgs > 1 && (Logger.IsInfoEnabled || Logger.IsDebugEnabled))
{
Logger.Info(string.Format(
"{0} Messages dropped for producer {1} from message id {2}",
advancedMsgs, prodIndex, lastId
));
}
msgIdWindow += advancedMsgs;
if (!persistent && msgIdWindow == NUM_MSGS)
{
this.waiter.Set();
}
}
}
};
connection.ExceptionListener += DefaultExceptionListener;
producers = new List <IMessageProducer>();
for (int i = 0; i < NUM_PRODUCERS; i++)
{
try
{
producer = session.CreateProducer(destination);
}
catch (Exception ex)
{
this.PrintTestFailureAndAssert(this.GetMethodName(), "Failed to Created Producer " + i, ex);
}
producer.DeliveryMode = mode;
producer.DisableMessageID = !useMsgId;
producer.TimeToLive = TimeSpan.FromMilliseconds(MSG_TTL_MILLIS);
producers.Add(producer);
lastProducerIndexedIds.Add(-1);
}
connection.Start();
Assert.AreEqual(NUM_PRODUCERS, producers.Count, "Did not create all producers.");
Assert.IsNull(asyncEx,
"Exception Listener Called While creating producers. With exception {0}.",
asyncEx);
ITextMessage msg = session.CreateTextMessage();
int producerIndex = -1;
for (int i = 0; i < NUM_MSGS; i++)
{
msg.Text = "Index:" + i;
msg.Properties[MSG_ID_KEY] = i;
msg.Properties[PRODUCER_INDEXED_ID_KEY] = i / NUM_PRODUCERS;
producerIndex = i % NUM_PRODUCERS;
msg.Properties[PRODUCER_ID_KEY] = producerIndex;
producers[producerIndex].Send(msg);
}
Assert.IsNull(asyncEx, "Exception Listener Called While sending messages. With exception {0}.", asyncEx);
Assert.IsTrue(waiter.WaitOne(TIMEOUT),
"Failed to received all messages in {0}ms. Received {1} of {2} messages",
TIMEOUT, msgCount, NUM_MSGS);
Assert.IsNull(failureErr,
"Received assertion failure from IMessageConsumer message Listener. Failure : {0}",
failureErr ?? "");
if (persistent)
{
Assert.AreEqual(NUM_MSGS, msgCount,
"Receive unexpected from messages sent. Message Window {0}", msgIdWindow);
}
else
{
int missedMsgs = (msgIdWindow - msgCount);
Assert.AreEqual(NUM_MSGS, msgIdWindow,
"Failed to receive all messages." +
" Received {0} of {1} messages, with missed messages {2}, in {3}ms",
msgCount, NUM_MSGS, missedMsgs, TIMEOUT
);
if (missedMsgs > 0)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
const string SEPARATOR = ", ";
for (int i = 0; i < NUM_PRODUCERS; i++)
{
sb.AppendFormat("Last received Producer {0} message id {1}{2}", i, lastProducerIndexedIds[i], SEPARATOR);
}
sb.Length = sb.Length - SEPARATOR.Length;
Logger.Warn(string.Format("Did not receive all Non Persistent messages. Received {0} of {1} messages. Where last received message ids = [{2}]", msgCount, NUM_MSGS, sb.ToString()));
}
}
Assert.IsNull(asyncEx, "Exception Listener Called While receiveing messages. With exception {0}.", asyncEx);
//
// Some brokers are sticklers for detail and actually honor the
// batchable flag that AMQPnetLite sets on all published messages. As
// a result all messages can be long received before the published
// messages are acknowledged. So to avoid a hand full of
// amqp:message:released outcomes, just pause a few seconds before
// closing the producer
System.Threading.Thread.Sleep(3000);
}
}
catch (Exception e)
{
this.PrintTestFailureAndAssert(this.GetMethodName(), "Unexpected Exception.", e);
}
finally
{
if (producers != null)
{
foreach (IMessageProducer p in producers)
{
p?.Close();
p?.Dispose();
}
producers.Clear();
}
}
}
public void TestCreateTemporaryDestination()
{
const int NUM_MSGS = 10;
try
{
using (IConnection connection = GetConnection("default"))
using (ISession session = GetSession("s1"))
{
IStreamMessage msg = session.CreateStreamMessage();
IDestination temp = session.CreateTemporaryQueue();
IMessageProducer producer = session.CreateProducer(temp);
for (int i = 0; i < NUM_MSGS; i++)
{
msg.WriteObject("barfoo");
msg.WriteObject(i);
msg.Properties.SetInt("count", i);
producer.Send(msg);
msg.ClearBody();
}
// Queues do not require an active consumer to receive messages.
// Create consumer on queue after messages sent and receive messages.
IMessageConsumer drain = session.CreateConsumer(temp);
connection.Start();
int msgsReceived = DrainDestination(drain, temp, NUM_MSGS);
Assert.AreEqual(NUM_MSGS, msgsReceived, "Received {0} of {1} on temporary destination {2}.", msgsReceived, NUM_MSGS, temp.ToString());
temp = session.CreateTemporaryTopic();
// Topics require an active consumer to receive messages.
drain = session.CreateConsumer(temp);
producer = session.CreateProducer(temp);
for (int i = 0; i < NUM_MSGS; i++)
{
msg.WriteObject("foobar");
msg.WriteObject(i);
msg.Properties.SetInt("count", i);
producer.Send(msg);
msg.ClearBody();
}
msgsReceived = DrainDestination(drain, temp, NUM_MSGS);
Assert.AreEqual(NUM_MSGS, msgsReceived, "Received {0} of {1} on temporary destination {2}.", msgsReceived, NUM_MSGS, temp.ToString());
}
}
catch (Exception ex)
{
this.PrintTestFailureAndAssert(GetTestMethodName(), "Unexpected exception.", ex);
}
}
public SharedConnectionProxy(SingleConnectionFactory factory, IConnection target, ILogger logger = null)
{
_logger = logger;
_factory = factory;
Target = target;
}
private void TestDestinationMessageDelivery(
IConnection connection,
ISession session,
IMessageProducer producer,
IDestination destination,
int msgPoolSize,
bool isDurable = false)
{
bool cleaned = !isDurable;
const string PROP_KEY = "send_msg_id";
string subName = DURABLE_SUBSRIPTION_NAME;
int TotalMsgSent = 0;
int TotalMsgRecv = 0;
MsgDeliveryMode initialMode = producer.DeliveryMode;
try
{
IMessageConsumer consumer = isDurable
?
session.CreateDurableConsumer(destination as ITopic, subName, null, false)
:
session.CreateConsumer(destination);
ITextMessage sendMessage = session.CreateTextMessage();
consumer.Listener += CreateListener(msgPoolSize);
connection.ExceptionListener += DefaultExceptionListener;
connection.Start();
for (int i = 0; i < msgPoolSize; i++)
{
sendMessage.Text = "Msg:" + i;
sendMessage.Properties.SetInt(PROP_KEY, TotalMsgSent);
producer.Send(sendMessage);
TotalMsgSent++;
}
bool signal = waiter.WaitOne(TIMEOUT);
TotalMsgRecv = msgCount;
Assert.IsTrue(signal,
"Timed out waiting to receive messages. Received {0} of {1} in {2}ms.",
msgCount, TotalMsgSent, TIMEOUT);
Assert.AreEqual(TotalMsgSent, msgCount,
"Failed to receive all messages. Received {0} of {1} in {2}ms.",
msgCount, TotalMsgSent, TIMEOUT);
// close consumer
consumer.Close();
// reset waiter
waiter.Reset();
for (int i = 0; i < msgPoolSize; i++)
{
sendMessage.Text = "Msg:" + i;
sendMessage.Properties.SetInt(PROP_KEY, TotalMsgSent);
producer.Send(sendMessage);
TotalMsgSent++;
if (isDurable || destination.IsQueue)
{
TotalMsgRecv++;
}
}
// Must stop connection before we can add a consumer
connection.Stop();
int expectedId = (isDurable || destination.IsQueue) ? msgPoolSize : TotalMsgSent;
// expectedMsgCount is 2 msgPoolSize groups for non-durable topics, one for initial send of pool size and one for final send of pool size.
// expedtedMsgCount is 3 msgPoolSize groups for queues and durable topics, same two groups for non-durable topic plus the group sent while there is no active consumer.
int expectedMsgCount = (isDurable || destination.IsQueue) ? 3 * msgPoolSize : 2 * msgPoolSize;
MessageListener callback = CreateListener(expectedMsgCount);
string errString = null;
consumer = consumer = isDurable
?
session.CreateDurableConsumer(destination as ITopic, subName, null, false)
:
session.CreateConsumer(destination);
consumer.Listener += (m) =>
{
int id = m.Properties.GetInt(PROP_KEY);
if (id != expectedId)
{
errString = string.Format("Received Message with unexpected msgId. Received msg : {0} Expected : {1}", id, expectedId);
waiter.Set();
return;
}
else
{
expectedId++;
}
callback(m);
};
// Start Connection
connection.Start();
for (int i = 0; i < msgPoolSize; i++)
{
sendMessage.Text = "Msg:" + i;
sendMessage.Properties.SetInt(PROP_KEY, TotalMsgSent);
producer.Send(sendMessage);
TotalMsgSent++;
TotalMsgRecv++;
}
signal = waiter.WaitOne(TIMEOUT);
Assert.IsNull(asyncEx, "Received asynchrounous exception. Message: {0}", asyncEx?.Message);
Assert.IsNull(errString, "Failure occured on Message Callback. Message : {0}", errString ?? "");
Assert.IsTrue(signal, "Timed out waiting for message receive. Received {0} of {1} in {2}ms.", msgCount, TotalMsgRecv, TIMEOUT);
Assert.AreEqual(TotalMsgRecv, msgCount,
"Failed to receive all messages. Received {0} of {1} in {2}ms.",
msgCount, TotalMsgRecv, TIMEOUT);
connection.Stop();
consumer.Close();
}
catch (Exception ex)
{
this.PrintTestFailureAndAssert(this.GetTestMethodName(), "Unexpected Exception", ex);
}
finally
{
if (!cleaned)
{
try
{
session.DeleteDurableConsumer(subName);
}
catch (InvalidDestinationException ide)
{
Logger.Info(string.Format("Unable to unsubscribe from {0}, Cause : {1}", subName, ide));
}
catch (Exception ex)
{
Logger.Warn(string.Format("Caught unexpected failure while unsubscribing from {0}. Failure : {1}", subName, ex));
}
}
}
}
public VeiculoDAO(IConnection connection)
{
this._conn = connection;
}
public MessagesController(IConnection rabbitConnection, MongoDbContext mongoDbContext)
{
_rabbitConnection = rabbitConnection;
_mongoDbContext = mongoDbContext;
}
public MonikerConnection(IConnection connection)
{
Fill(connection.GetConnectionString());
}
public abstract SingleDownload MakeDownload(IConnection connection);
public Criteria(Type type, IConnection connection, IConnectionFactorySupport factory)
: this(factory.Mapping.FindTable(type), connection, factory)
{
_type = type;
}
public Criteria(String entity, IConnection connection, IConnectionFactorySupport factory)
: this(factory.Mapping.FindTable(entity), connection, factory)
{
_entity = entity;
}
public static async Task<SchemaModel> ReadSchema(IConnection connection)
{
var query = new IntrospectionQuery()
.Schema
.Select(x => new SchemaModel
{
QueryType = x.QueryType.Name,
MutationType = x.MutationType.Name,
Types = x.Types.Select(t => new TypeModel
{
Kind = t.Kind,
Name = t.Name,
Description = t.Description,
Fields = t.Fields(true).Select((Field f) => new FieldModel
{
Name = f.Name,
Description = f.Description,
Type = f.Type.Select((SchemaType t1) => new TypeModel
{
Kind = t1.Kind,
Name = t1.Name,
OfType = t1.OfType.Select((SchemaType t2) => new TypeModel
{
Kind = t2.Kind,
Name = t2.Name,
OfType = t2.OfType.Select((SchemaType t3) => new TypeModel
{
Kind = t3.Kind,
Name = t3.Name,
OfType = t3.OfType.Select((SchemaType t4) => new TypeModel
{
Kind = t4.Kind,
Name = t4.Name,
}).SingleOrDefault(),
}).SingleOrDefault(),
}).SingleOrDefault(),
}).Single(),
Args = f.Args.Select((InputValue a) => new InputValueModel
{
Name = a.Name,
Description = a.Description,
DefaultValue = a.DefaultValue,
Type = a.Type.Select((SchemaType t1) => new TypeModel
{
Kind = t1.Kind,
Name = t1.Name,
OfType = t1.OfType.Select((SchemaType t2) => new TypeModel
{
Kind = t2.Kind,
Name = t2.Name,
OfType = t2.OfType.Select((SchemaType t3) => new TypeModel
{
Kind = t3.Kind,
Name = t3.Name,
OfType = t3.OfType.Select((SchemaType t4) => new TypeModel
{
Kind = t4.Kind,
Name = t4.Name,
}).SingleOrDefault(),
}).SingleOrDefault(),
}).SingleOrDefault(),
}).Single(),
}).ToList(),
IsDeprecated = f.IsDeprecated,
DeprecationReason = f.DeprecationReason,
}).ToList(),
EnumValues = t.EnumValues(true).Select((EnumValue e) => new EnumValueModel
{
Name = e.Name,
Description = e.Description,
IsDeprecated = e.IsDeprecated,
DeprecationReason = e.DeprecationReason,
}).ToList(),
InputFields = t.InputFields.Select((InputValue i) => new InputValueModel
{
Name = i.Name,
Description = i.Description,
DefaultValue = i.DefaultValue,
Type = i.Type.Select((SchemaType t1) => new TypeModel
{
Kind = t1.Kind,
Name = t1.Name,
OfType = t1.OfType.Select((SchemaType t2) => new TypeModel
{
Kind = t2.Kind,
Name = t2.Name,
OfType = t2.OfType.Select((SchemaType t3) => new TypeModel
{
Kind = t3.Kind,
Name = t3.Name,
OfType = t3.OfType.Select((SchemaType t4) => new TypeModel
{
Kind = t4.Kind,
Name = t4.Name,
}).SingleOrDefault(),
}).SingleOrDefault(),
}).SingleOrDefault(),
}).Single(),
}).ToList(),
PossibleTypes = t.PossibleTypes.Select((SchemaType t1) => new TypeModel
{
Kind = t1.Kind,
Name = t1.Name,
Description = t1.Description,
OfType = t1.OfType.Select((SchemaType t2) => new TypeModel
{
Kind = t2.Kind,
Name = t2.Name,
OfType = t2.OfType.Select((SchemaType t3) => new TypeModel
{
Kind = t3.Kind,
Name = t3.Name,
OfType = t3.OfType.Select((SchemaType t4) => new TypeModel
{
Kind = t4.Kind,
Name = t4.Name,
}).SingleOrDefault(),
}).SingleOrDefault(),
}).SingleOrDefault(),
}).ToList(),
}).ToList()
});
return await connection.Run(query).ConfigureAwait(false);
}
/// <summary>
/// Creates a new <see cref="BackstoryClient"/> that is used for the API v2 backstory endpoint.
/// </summary>
/// <param name="connection">The connection used to make requests, see <see cref="IConnection"/>.</param>
/// <param name="gw2Client">The Guild Wars 2 client.</param>
/// <exception cref="ArgumentNullException"><paramref name="connection"/> or <paramref name="gw2Client"/> is <see langword="null"/>.</exception>
protected internal BackstoryClient(IConnection connection, IGw2Client gw2Client) :
base(connection, gw2Client)
{
this.answers = new BackstoryAnswersClient(connection, gw2Client);
this.questions = new BackstoryQuestionsClient(connection, gw2Client);
}