async Task SessionLockLostExceptionTest()
{
var sender = new MessageSender(TestUtility.NamespaceConnectionString, TestConstants.SessionNonPartitionedQueueName);
var sessionClient = new SessionClient(TestUtility.NamespaceConnectionString, TestConstants.SessionNonPartitionedQueueName);
try
{
var messageId = "test-message1";
var sessionId = Guid.NewGuid().ToString();
await sender.SendAsync(new Message { MessageId = messageId, SessionId = sessionId });
TestUtility.Log($"Sent Message: {messageId} to Session: {sessionId}");
var sessionReceiver = await sessionClient.AcceptMessageSessionAsync(sessionId);
Assert.NotNull(sessionReceiver);
TestUtility.Log($"Received Session: SessionId: {sessionReceiver.SessionId}: LockedUntilUtc: {sessionReceiver.LockedUntilUtc}");
var message = await sessionReceiver.ReceiveAsync();
Assert.True(message.MessageId == messageId);
TestUtility.Log($"Received Message: MessageId: {message.MessageId}");
// Let the Session expire with some buffer time
TestUtility.Log($"Waiting for session lock to time out...");
await Task.Delay((sessionReceiver.LockedUntilUtc - DateTime.UtcNow) + TimeSpan.FromSeconds(10));
await Assert.ThrowsAsync <SessionLockLostException>(async() => await sessionReceiver.ReceiveAsync());
await Assert.ThrowsAsync <SessionLockLostException>(async() => await sessionReceiver.RenewSessionLockAsync());
await Assert.ThrowsAsync <SessionLockLostException>(async() => await sessionReceiver.GetStateAsync());
await Assert.ThrowsAsync <SessionLockLostException>(async() => await sessionReceiver.SetStateAsync(null));
await Assert.ThrowsAsync <SessionLockLostException>(async() => await sessionReceiver.CompleteAsync(message.SystemProperties.LockToken));
await sessionReceiver.CloseAsync();
TestUtility.Log($"Closed Session Receiver...");
//Accept a new Session and Complete the message
sessionReceiver = await sessionClient.AcceptMessageSessionAsync(sessionId);
Assert.NotNull(sessionReceiver);
TestUtility.Log($"Received Session: SessionId: {sessionReceiver.SessionId}");
message = await sessionReceiver.ReceiveAsync();
TestUtility.Log($"Received Message: MessageId: {message.MessageId}");
await sessionReceiver.CompleteAsync(message.SystemProperties.LockToken);
await sessionReceiver.CloseAsync();
}
finally
{
await sender.CloseAsync();
await sessionClient.CloseAsync();
}
}
public void Initialize()
{
client = new SessionClient();
client.ClientCredentials.UserName.UserName = "******";
client.ClientCredentials.UserName.Password = "******";
}
/// <summary>
/// 下载图片
/// </summary>
public void DownloadImg(int id, string url, string needReferer)
{
try
{
#region 创建请求数据
SessionClient ss = new SessionClient();
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
req.Proxy = MainWindow.WebProxy;
req.UserAgent = "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36";
req.Headers[HttpRequestHeader.AcceptEncoding] = "gzip, deflate";
if (needReferer != null)
{
req.Referer = needReferer;
}
req.AllowAutoRedirect = true;
req.CookieContainer = ss.CookieContainer;
//将请求加入请求组
reqs.Add(id, req);
#endregion
//异步下载开始
req.BeginGetResponse(new AsyncCallback(RespCallback), new KeyValuePair <int, HttpWebRequest>(id, req));
}
catch (Exception ex)
{
Program.Log(ex, "Download sample failed");
StopLoadImg(id, true, "创建下载失败");
}
}
public ActionToken Send(byte[] data, Action <IActionItem> completedCallback)
{
return(SessionClient.ExecuteAsync(new SendOperation(data)
{
CompletedCallback = completedCallback
}));
}
public ActionToken Request(byte[] data, ByteIndex[] mask, int timeoutMs, Action <IActionItem> completedCallback)
{
return(SessionClient.ExecuteAsync(new RequestOperation(data, mask, timeoutMs)
{
CompletedCallback = completedCallback
}));
}
private void Application_PostAuthenticateRequest(object sender, EventArgs e)
{
HttpCookie authCookie = HttpContext.Current.Request.Cookies[FormsAuthentication.FormsCookieName];
if (authCookie != null)
{
//Extract the forms authentication cookie
FormsAuthenticationTicket authTicket = FormsAuthentication.Decrypt(authCookie.Value);
// If caching roles in userData field then extract
string clientId = authTicket.UserData;
// Create the IIdentity instance
IIdentity id = new FormsIdentity(authTicket);
CClientInfo clientInfo = SessionClient.GetClientInfo(true);
//if (clientInfo == null)
// clientInfo = SessionClient.GetClientInfo(true);
// Create the IPrinciple instance
IPrincipal principal = new UltimaPrincipal(id, clientInfo);
// Set the context user
HttpContext.Current.User = principal;
System.Threading.Thread.CurrentPrincipal = principal;
}
}
public ActionToken Expect(ByteIndex[] mask, int timeoutMs, Action <IActionItem> completedCallback)
{
return(SessionClient.ExecuteAsync(new ExpectOperation(mask, timeoutMs)
{
CompletedCallback = completedCallback
}));
}
async Task EventsAreNotFiredWhenDiagnosticsIsDisabled()
{
this.messageSender = new MessageSender(TestUtility.NamespaceConnectionString,
TestConstants.SessionNonPartitionedQueueName);
this.sessionClient = new SessionClient(TestUtility.NamespaceConnectionString,
TestConstants.SessionNonPartitionedQueueName, ReceiveMode.ReceiveAndDelete);
this.listener.Disable();
var sessionId = Guid.NewGuid().ToString();
await this.messageSender.SendAsync(new Message
{
MessageId = "messageId",
SessionId = sessionId
});
this.messageSession = await sessionClient.AcceptMessageSessionAsync(sessionId);
await this.messageSession.SetStateAsync(new byte[] { 1 });
await this.messageSession.GetStateAsync();
await this.messageSession.SetStateAsync(new byte[] { });
await this.messageSession.ReceiveAsync();
Assert.True(events.IsEmpty);
}
private void LoadSessionClient()
{
currentSessionClient = Argument.SessionView.CurrentSessionClient;
View.ConnectionName = currentSessionClient.Name;
View.ConnectionSurname = currentSessionClient.Surname;
View.ConnectionPatronimyc = currentSessionClient.Patronymic;
View.TicketName = $"Билет '{Argument.Session.Exam.Tickets.Single(a => a.TicketNumber == currentSessionClient.TicketNumber).TicketName}'";
View.ClientStatus = currentSessionClient.ClientStatus;
View.Points = currentSessionClient.Points;
View.Mark = currentSessionClient.ExecutionResult?.Mark ?? 0;
View.ClearViolations();
View.ClearStatuses();
int i;
for (i = 0; i < currentSessionClient.ClientStatuses.Count; i++)
{
View.AddStatus(currentSessionClient.ClientStatuses[i].CurrentQuestionNumber + Argument.Session.Exam.FirstQuestionNumber, currentSessionClient.ClientStatuses[i].ExecutedQuestions, currentSessionClient.ClientStatuses[i].TimeOffset);
}
for (i = 0; i < currentSessionClient.Violations.Count; i++)
{
View.AddViolation($"№{i + 1} [{Argument.Session.InitializeTime.Value.AddSeconds(currentSessionClient.Violations[i].TimeOffset)}] {currentSessionClient.Violations[i].Content}", currentSessionClient.Violations[i].TimeOffset);
}
}
private static async Task ReceiveSessionMessages(string queueName)
{
var sessionClient = new SessionClient(SBConnectionString, queueName, ReceiveMode.ReceiveAndDelete);
var session = await sessionClient.AcceptMessageSessionAsync();
if (session != null)
{
while (true)
{
var msg = await session.ReceiveAsync(TimeSpan.FromSeconds(2));
if (msg == null)
{
break;
}
var bodyAsString = Encoding.UTF8.GetString(msg.Body);
var seqNo = msg.SystemProperties.SequenceNumber;
Print.White($"{seqNo}--{msg.SessionId}--{bodyAsString}");
}
Console.WriteLine($"Received all messages for Session: {session.SessionId}");
Console.WriteLine("=====================================");
await session.CloseAsync();
}
}
/// <summary>
/// Get endpoint from session
/// </summary>
/// <param name="session"></param>
/// <returns></returns>
public static EndpointIdentifier GetEndpointId(SessionClient session)
{
var endpointModel = new EndpointModel {
Url = session.Endpoint.EndpointUrl.TrimEnd('/'),
SecurityPolicy = session.Endpoint.SecurityPolicyUri
};
switch (session.Endpoint.SecurityMode)
{
case MessageSecurityMode.Invalid:
throw new Exception("Invalid security mode: invalid");
case MessageSecurityMode.None:
endpointModel.SecurityMode = SecurityMode.None;
break;
case MessageSecurityMode.Sign:
endpointModel.SecurityMode = SecurityMode.Sign;
break;
case MessageSecurityMode.SignAndEncrypt:
endpointModel.SecurityMode = SecurityMode.SignAndEncrypt;
break;
}
return(new EndpointIdentifier(endpointModel));
}
public MainWindow(SessionClient client)
{
InitializeComponent();
InitializeFileSystemObjects();
this.client = client;
}
void testAchievements(SessionClient session)
{
Client.Achievements((AchievementList a) => {
IEnumerator <Achievement> en = a.GetEnumerator();
en.MoveNext();
Debug.Log("Achievements Count: " + a.Count + " " + en.Current.Name);
}, failure);
session.Achievement(achievementId, () => {
Debug.Log("Updated achievement");
session.Achievements((AchievementList al) => {
Debug.Log("Retrieved achievements " + al.Count);
foreach (Achievement entry in al.Achievements)
{
Debug.LogFormat("Name: " + entry.Name + " state: " + entry.State);
Debug.LogFormat("iscompleted: " + entry.IsCompleted());
}
}, failure);
}, (Achievement a) => {
Debug.Log("Unlocked achievement");
}, failure);
session.Achievements((AchievementList al) => {
Debug.Log("Retrieved achievements " + al.Count);
foreach (Achievement entry in al.Achievements)
{
Debug.LogFormat("Name: " + entry.Name + " state: " + entry.State);
}
}, failure);
}
void testScriptExecution(SessionClient session)
{
IDictionary <string, object> scriptData = new Dictionary <string, object> ();
scriptData.Add("a", 1);
scriptData.Add("b", 2);
session.executeScript(scriptId, scriptData, (IDictionary <string, object> response) => {
Debug.Log("Executed script with result:" + GameUp.SimpleJson.SerializeObject(response));
}, failure);
session.executeScript(mailboxScriptId, scriptData, (IDictionary <string, object> response) => {
Debug.Log("Executed mailbox");
session.MessageList(false, (MessageList ms) => {
Debug.Log("Got " + ms.Count + " messages back");
IEnumerator <Message> messages = ms.GetEnumerator();
messages.MoveNext();
session.MessageGet(messages.Current.MessageId, true, (Message message) => {
Debug.Log("Got message with ID" + message.MessageId + " with subject: " + message.Subject);
session.MessageDelete(messages.Current.MessageId, () => {
Debug.Log("Deleted message with ID" + message.MessageId);
}, failure);
}, failure);
}, failure);
}, failure);
session.executeCloudCodeFunction("test", "log", scriptData, (IDictionary <string, object> response) => {
Debug.Log("Executed cloud code with result:" + GameUp.SimpleJson.SerializeObject(response));
}, failure);
}
void testLeaderboard(SessionClient session)
{
Client.Leaderboards((LeaderboardList list) => {
foreach (Leaderboard entry in list.Leaderboards)
{
Debug.LogFormat("Name: " + entry.Name + " sort: " + entry.Sort);
if (entry.LeaderboardReset != null)
{
Debug.LogFormat("Name: " + entry.Name + " reset type: " + entry.LeaderboardReset.Type + " reset hr: " + entry.LeaderboardReset.UtcHour);
}
else
{
Debug.LogFormat("Name: " + entry.Name + " has no reset!");
}
}
}, failure);
Client.Leaderboard(leaderboardId, 10, 20, false, (Leaderboard l) => {
foreach (Leaderboard.Entry en in l.Entries)
{
Debug.Log("Leaderboard Name: " + l.Name + " " + l.PublicId + " " + l.Sort + " " + l.Type + " " + l.Entries.Length + " " + en.Name);
}
}, failure);
session.UpdateLeaderboard(leaderboardId, DateTime.Now.Millisecond, (Rank r) => {
Debug.Log("Updated leaderboard. New rank " + r.Ranking + " for " + r.Name);
}, failure);
ScoretagTest scoretagtest = new ScoretagTest();
scoretagtest.Datetime = DateTime.Now.Millisecond;
session.UpdateLeaderboard(leaderboardId, DateTime.Now.Millisecond, scoretagtest, (Rank r) => {
Debug.Log("Updated leaderboard with scoretags. New rank " + r.Ranking + " for " + r.Name + " with tags " + r.Scoretags.ToString());
}, failure);
session.LeaderboardAndRank(leaderboardId, (LeaderboardAndRank lr) => {
Debug.Log("1-Retrieved Leaderboard and Rank: " + lr.Leaderboard.Name);
Debug.Log("1-Retrieved Leaderboard and Rank: " + lr.Rank.Name + " " + lr.Rank.Ranking);
}, failure);
session.LeaderboardAndRank(leaderboardId, 10, (LeaderboardAndRank lr) => {
Debug.Log("2-Retrieved Leaderboard Entries count: " + lr.Leaderboard.Entries.Length);
Debug.Log("2-Retrieved Leaderboard and Rank: " + lr.Leaderboard.Name);
Debug.Log("2-Retrieved Leaderboard and Rank: " + lr.Rank.Name);
if (lr.Rank.Scoretags != null)
{
Debug.Log("2-ScoreTags: " + lr.Rank.Scoretags.ToString());
}
}, failure);
session.LeaderboardAndRank(leaderboardId, 10, 20, (LeaderboardAndRank lr) => {
Debug.Log("3-Retrieved Leaderboard Entries count: " + lr.Leaderboard.Entries.Length);
Debug.Log("3-Retrieved Leaderboard and Rank: " + lr.Leaderboard.Name);
Debug.Log("3-Retrieved Leaderboard and Rank: " + lr.Rank.Name);
if (lr.Rank.Scoretags != null)
{
Debug.Log("3-ScoreTags: " + lr.Rank.Scoretags.ToString());
}
}, failure);
}
void testDatastore(SessionClient session)
{
Dictionary <string, object> armyData = new Dictionary <string, object> ();
armyData.Add("soldiers", 1000);
armyData.Add("tombstones", 10);
session.DatastorePut(datastore_table, datastore_key, armyData, DatastorePermission.ReadWrite, () => {
Debug.Log("Datastore PUT: " + datastore_key);
session.DatastoreGet(datastore_table, datastore_key, "me", (DatastoreObject o) => {
Debug.Log("Retrieved datastore object owner: " + o.Metadata.Owner);
Debug.Log("Retrieved datastore object data: " + GameUp.SimpleJson.SerializeObject(o.Data));
armyData.Remove("soldiers");
armyData.Add("soldiers", 1);
session.DatastoreUpdate(datastore_table, datastore_key, armyData, () => {
Debug.Log("Updated Datastore data: " + datastore_key);
session.DatastoreQuery(datastore_table, "value.tombstones > 5", (DatastoreSearchResultList results) => {
Debug.Log("Searched shared storage: " + results.Count);
foreach (DatastoreObject result in results)
{
Debug.Log("Retrieved datastore object owner: " + result.Metadata.Owner);
Debug.Log("Retrieved datastore object data: " + GameUp.SimpleJson.SerializeObject(result.Data));
}
session.DatastoreDelete(datastore_table, datastore_key, () => {
Debug.Log("Deleted datastore key: " + datastore_key);
}, failure);
}, failure);
}, failure);
}, failure);
}, failure);
}
public override MessageContext ReceiveOnTopic(MessageContext inputcontext, IMessageAdapter adapter)
{
var entity = EntityNameHelper.FormatSubscriptionPath(inputcontext.ToReplyPath, inputcontext.ToReplySubscription);
var client = new SessionClient(inputcontext.ToReplyConnectionString, entity);
var messagesession = client.AcceptMessageSessionAsync(inputcontext.ReplyToRequestId).GetAwaiter().GetResult();
var message = inputcontext.ToReplyTimeOut != 0 ? messagesession.ReceiveAsync(TimeSpan.FromSeconds(inputcontext.ToReplyTimeOut)).GetAwaiter().GetResult() : messagesession.ReceiveAsync().GetAwaiter().GetResult();
MessageContext outputcontext = null;
if (message != null)
{
outputcontext = adapter.Read(message, inputcontext.ResultType);
messagesession.CompleteAsync(message.SystemProperties.LockToken);
}
messagesession.CloseAsync().GetAwaiter().GetResult();
client.CloseAsync().GetAwaiter().GetResult();
return(outputcontext);
}
async Task PeekSessionAsyncTest(string queueName, int messageCount = 10)
{
var sender = new MessageSender(TestUtility.NamespaceConnectionString, queueName);
var sessionClient = new SessionClient(TestUtility.NamespaceConnectionString, queueName, ReceiveMode.ReceiveAndDelete);
try
{
var messageId1 = "test-message1";
var sessionId1 = "sessionId1";
await sender.SendAsync(new Message { MessageId = messageId1, SessionId = sessionId1 });
TestUtility.Log($"Sent Message: {messageId1} to Session: {sessionId1}");
var messageId2 = "test-message2";
var sessionId2 = "sessionId2";
await sender.SendAsync(new Message { MessageId = messageId2, SessionId = sessionId2 });
TestUtility.Log($"Sent Message: {messageId2} to Session: {sessionId2}");
// Peek Message, Receive and Delete with SessionId - sessionId 1
await this.PeekAndDeleteMessageAsync(sessionClient, sessionId1, messageId1);
// Peek Message, Receive and Delete with SessionId - sessionId 2
await this.PeekAndDeleteMessageAsync(sessionClient, sessionId2, messageId2);
}
finally
{
await sender.CloseAsync().ConfigureAwait(false);
await sessionClient.CloseAsync().ConfigureAwait(false);
}
}
public async Task ReceiveDeferredMessageForSessionTest(string qName)
{
var sessionId = Guid.NewGuid().ToString("N").Substring(0, 8);
var messageId = Guid.NewGuid().ToString("N").Substring(0, 8);
var sender = new MessageSender(TestUtility.NamespaceConnectionString, qName);
await sender.SendAsync(new Message()
{
SessionId = sessionId, MessageId = messageId
});
var sessionClient = new SessionClient(TestUtility.NamespaceConnectionString, qName);
var messageSession = await sessionClient.AcceptMessageSessionAsync(sessionId);
var msg = await messageSession.ReceiveAsync();
var seqNum = msg.SystemProperties.SequenceNumber;
await messageSession.DeferAsync(msg.SystemProperties.LockToken);
var msg2 = await messageSession.ReceiveDeferredMessageAsync(seqNum);
Assert.Equal(seqNum, msg2.SystemProperties.SequenceNumber);
Assert.Equal(messageId, msg2.MessageId);
await sender.CloseAsync();
await sessionClient.CloseAsync();
await messageSession.CloseAsync();
}
public void GetUserSessionFromCookieReturnsSessionWhenCookieExists()
{
// Arrange
var userSession = new DfcUserSession
{
SessionId = "DummySessionId",
Salt = "DummySalt",
CreatedDate = DateTime.UtcNow,
PartitionKey = "DummyPartitionKey",
};
var userSessionJson = JsonConvert.SerializeObject(userSession);
var httpContext = A.Fake <HttpContext>();
var localHttpContextAccessor = new HttpContextAccessor {
HttpContext = httpContext
};
var cookies = new RequestCookieCollection(new Dictionary <string, string> {
{ SessionName, userSessionJson }
});
A.CallTo(() => localHttpContextAccessor.HttpContext.Request.Cookies).Returns(cookies);
var localSessionClient = new SessionClient(sessionIdGenerator, partitionKeyGenerator, localHttpContextAccessor, config, logger);
// Act
var result = localSessionClient.GetUserSessionFromCookie();
// Assert
Assert.Equal(userSession.GetCookieSessionId, result.GetCookieSessionId);
}
private async void btnLogin_Click(object sender, EventArgs e)
{
uid = txtUser.Text;
string pwd = pswd.Text;
if (string.IsNullOrEmpty(uid) || string.IsNullOrEmpty(pwd) || uid.Length != 5 || pwd.Length != 6)
{
MessageBox.Show("login", "user/password invalid!");
return;
}
try
{
AnClient.Init(txtUrl.Text);
await AnClient.Login(uid, "----------" + pwd,
(code, resp) =>
{
client = new SessionClient(resp.ssInf);
txtRegistry.Text = client.ssInf.ssid;
});
}
catch (Exception x)
{
MessageBox.Show(x.Message, "Jserv Login Exception");
}
}
public MouseTracker(SessionClient sc)
{
InitializeComponent();
this.sc = sc;
this.MouseDown += mousePressed;
this.MouseUp += mouseReleased;
this.MouseMove += mouseMoved;
//this.MouseWheel += mouseWheelMoved;
Text.PreviewKeyDown += keyPressed;
Text.PreviewKeyUp += keyReleased;
Text.TextChanged += textChanged;
socket = new UdpClient();
Start st = new Start();
st.Type = "start";
st.Name = App.name;
if (sc.mode != 0)
{
st.Code = App.code % sc.mode;
}
Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(st)));
Text.LostKeyboardFocus += delegate
{
if (this.IsActive)
{
Keyboard.Focus(Text);
}
};
this.Activated += delegate
{
Keyboard.Focus(Text);
};
}
public void ExecuteAsync(ActionBase action, Action <IActionItem> completedCallback)
{
action.CompletedCallback = completedCallback;
action.Token.LogEntryPointCategory = "Text";
action.Token.LogEntryPointSource = DataSource == null ? "" : DataSource.SourceName;
SessionClient.ExecuteAsync(action);
}
private static async Task StartSessionSender(string sessionId, ConsoleColor color)
{
var message = new Message
{
ReplyToSessionId = sessionId,
ReplyTo = "sender"
};
var sender = new MessageSender(Configuration.ServiceBusConnectionString, "worker");
await sender.SendAsync(message);
Logger.Log($"[{sessionId}] write to worker queue", color);
var client = new SessionClient(Configuration.ServiceBusConnectionString, "sender");
var session = await client.AcceptMessageSessionAsync(sessionId, new TimeSpan(0, 1, 0));
while (true)
{
if (session.IsClosedOrClosing)
{
return;
}
var receivedMessage = await session.ReceiveAsync();
if (receivedMessage == null)
{
continue;
}
Logger.Log($"[{sessionId}] Received message {receivedMessage.UserProperties["result"]}", color);
await session.CompleteAsync(receivedMessage.SystemProperties.LockToken);
}
}
public SessionClientWrapper(Chanel2Server serverData, SessionClient sessionClient)
{
Chanel2Server = serverData;
_sessionClient = sessionClient;
updateClientData();
}
/**
* Is invoked when application launches. Connects the Client to the Server
*/
public void OnUserConnect(string address, int port)
{
ChannelDispatcher dispatcher = new ChannelDispatcher();
this.transport = new TransportClient(dispatcher);
sessionClient = new SessionClient(this.transport, this);
dispatcher.RegisterChannel(sessionClient);
surfaceClient = new SurfaceClient(this, this.transport);
dispatcher.RegisterChannel(surfaceClient);
inputClient = new InputClient(this.transport);
dispatcher.RegisterChannel(inputClient);
try
{
this.transport.Connect(address, port);
DisplayStatusText("Welcome! You are connected to Screenary server at " + address + " : " + port);
}
catch (TransportException e)
{
ExceptionDialog exception = new ExceptionDialog("Operation Fail", "Could not connect to Screenary server at "
+ address + " : " + port + "\nVerify connections.");
}
}
public async Task GetByKeyAsync_sends_ok()
{
var handler = new Mock <HttpMessageHandler>();
handler.Protected()
.Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>())
.ReturnsAsync(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(string.Empty)
});
var httpClient = new HttpClient(handler.Object)
{
BaseAddress = this.baseAddress
};
var client = new SessionClient(httpClient);
var sessionKey = "42";
await client.GetByKeyAsync(sessionKey);
handler.Protected().Verify(
"SendAsync",
Times.Once(),
ItExpr.Is <HttpRequestMessage>(req =>
req.Method == HttpMethod.Get &&
req.RequestUri == new Uri("https://localhost:5001/api/session/42")),
ItExpr.IsAny <CancellationToken>());
}
void testGamer(SessionClient session)
{
session.Gamer((Gamer gamer) => {
Debug.Log("Gamer Name: " + gamer.Name);
Debug.Log("Gamer ID: " + gamer.GamerId);
}, failure);
Client.CreateEmailAccount("*****@*****.**", "password", "password", "UnitySDK Test", session, (SessionClient gus) => {
session = gus;
Debug.Log("Created GameUp Account: " + session.Token);
}, (status, reason) => {
Client.LoginEmail("*****@*****.**", "password", (SessionClient gus) => {
Debug.Log("Logged in with GameUp Account: " + session.Token);
}, failure);
});
Client.linkFacebook(session, facebookToken, () => {
Debug.Log("Facebook Linking successful: ");
}, (status, reason) => {
Debug.Log("[Expected Failure] Facebook Linking Failed: " + status + " " + reason);
});
session.UpdateGamer("UnitySDKTest", () => {
Debug.Log("Updated gamer's profile");
}, failure);
}
public async Task TryFindSessionCodeUsesQueryDataWhenOnlyQueryStringAndCookieSourcesExist()
{
// Arrange
const string expectedQueryStringValue = "qsValue";
var userSession = new DfcUserSession
{
SessionId = "DummySessionId",
Salt = "DummySalt",
CreatedDate = DateTime.UtcNow,
PartitionKey = "DummyPartitionKey",
};
var userSessionJson = JsonConvert.SerializeObject(userSession);
var httpContext = A.Fake <HttpContext>();
var dummyQueryString = new QueryString($"?{SessionName.TrimStart('.')}={expectedQueryStringValue}");
var cookies = new RequestCookieCollection(new Dictionary <string, string> {
{ SessionName, userSessionJson }
});
var localHttpContextAccessor = new HttpContextAccessor {
HttpContext = httpContext
};
A.CallTo(() => localHttpContextAccessor.HttpContext.Request.Cookies).Returns(cookies);
A.CallTo(() => localHttpContextAccessor.HttpContext.Request.QueryString).Returns(dummyQueryString);
var localSessionClient = new SessionClient(sessionIdGenerator, partitionKeyGenerator, localHttpContextAccessor, config, logger);
// Act
var result = await localSessionClient.TryFindSessionCode().ConfigureAwait(false);
// Assert
Assert.Equal(expectedQueryStringValue, result);
}
private static async Task CleanUpEntity(string connectionString, string entityPAth)
{
var client = new SessionClient(connectionString, entityPAth, ReceiveMode.PeekLock);
client.OperationTimeout = TimeSpan.FromSeconds(5);
IMessageSession session = null;
try
{
session = await client.AcceptMessageSessionAsync();
var messages = await session.ReceiveAsync(1000, TimeSpan.FromSeconds(1));
await session.CompleteAsync(messages.Select(m => m.SystemProperties.LockToken));
}
catch (ServiceBusException)
{
}
finally
{
if (session != null)
{
await session.CloseAsync();
}
}
}
public LunoClient(ApiKeyConnection connection)
: base(connection)
{
Analytics = new AnalyticsClient(connection);
ApiAuthentication = new ApiAuthenticationClient(connection);
Event = new EventClient(connection);
Session = new SessionClient(connection);
User = new UsersClient(connection);
}
public App()
{
_clientSession = new SessionClient();
_clientSession.GetSessionAsync(CurrentSystemInfo.SessionKey);
_clientSession.GetSessionCompleted+=GetSessionCompleted;
AppSettings = IsolatedStorageSettings.ApplicationSettings;
this.Startup += this.Application_Startup;
this.Exit += this.Application_Exit;
this.UnhandledException += this.Application_UnhandledException;
InitializeComponent();
}
private void Load()
{
_client =new SessionClient();
_client.SetSessionCompleted += _client_SetSessionCompleted;
}
// heitetään factoryltä tulevat clientit basemapperille
public AssemblyMapper(WebClient webClient, LocalClient localClient, SessionClient sessionClient)
: base(webClient, localClient, sessionClient)
{
}
/// <summary>
/// Queues an action.
/// </summary>
private void QueueStackAction(SessionClient session, StackAction action)
{
System.ServiceModel.ClientBase<ISessionChannel> channel = session.InnerChannel as System.ServiceModel.ClientBase<ISessionChannel>;
if (channel != null)
{
IStackControl control = channel.InnerChannel.GetProperty<IStackControl>();
if (control != null)
{
control.QueueAction(action);
}
}
}
// heitetään factoryltä tulevat clientit basemapperille
public TrainTypeMapper(WebClient webClient, LocalClient localClient, SessionClient sessionClient)
: base(webClient, localClient, sessionClient)
{
}
// heitetään factoryltä tulevat clientit basemapperille
public ReasonCodeMapper(WebClient webClient, LocalClient localClient, SessionClient sessionClient)
: base(webClient, localClient, sessionClient)
{
}
// heitetään factoryltä tulevat clientit basemapperille
public TrafficLocationMapper(WebClient webClient, LocalClient localClient, SessionClient sessionClient)
: base(webClient, localClient, sessionClient)
{
}
public vm_LoginSystem()
{
_clientUser = new TL_USERClient();
_clientUser.TL_USER_GetSiginDataCompleted+=GetSiginDataCompleted;
_clientSession = new SessionClient();
_clientSession.SetSessionCompleted+=SetSessionCompleted;
LoginCommand = new RelayCommand(OnLoginCommand);
HasError = false;
IsCheckPass = false;
string culture = IsolatedStorageSettings.ApplicationSettings["currentCulture"].ToString();
if (culture.Equals("vi-VN"))
IsCheckVN = true;
else
IsCheckVN = false;
// Set default value for testing
UserName = "******";
Password = "******";
}
/// <summary>
/// Runs the test in a background thread.
/// </summary>
private void DoTest(ConfiguredEndpoint endpoint)
{
PerformanceTestResult result = new PerformanceTestResult(endpoint, 100);
result.Results.Add(1, -1);
result.Results.Add(10, -1);
result.Results.Add(50, -1);
result.Results.Add(100, -1);
result.Results.Add(250, -1);
result.Results.Add(500, -1);
try
{
// update the endpoint.
if (endpoint.UpdateBeforeConnect)
{
endpoint.UpdateFromServer();
}
SessionClient client = null;
Uri url = new Uri(endpoint.Description.EndpointUrl);
ITransportChannel channel = SessionChannel.Create(
m_configuration,
endpoint.Description,
endpoint.Configuration,
m_clientCertificate,
m_messageContext);
client = new SessionClient(channel);
List<int> requestSizes = new List<int>(result.Results.Keys);
for (int ii = 0; ii < requestSizes.Count; ii++)
{
// update the progress indicator.
TestProgress((ii * 100) / requestSizes.Count);
lock (m_lock)
{
if (!m_running)
{
break;
}
}
int count = requestSizes[ii];
// initialize request.
RequestHeader requestHeader = new RequestHeader();
requestHeader.ReturnDiagnostics = 5000;
ReadValueIdCollection nodesToRead = new ReadValueIdCollection(count);
for (int jj = 0; jj < count; jj++)
{
ReadValueId item = new ReadValueId();
item.NodeId = new NodeId((uint)jj, 1);
item.AttributeId = Attributes.Value;
nodesToRead.Add(item);
}
// ensure valid connection.
DataValueCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
client.Read(
requestHeader,
0,
TimestampsToReturn.Both,
nodesToRead,
out results,
out diagnosticInfos);
if (results.Count != count)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
// do test.
DateTime start = DateTime.UtcNow;
for (int jj = 0; jj < result.Iterations; jj++)
{
client.Read(
requestHeader,
0,
TimestampsToReturn.Both,
nodesToRead,
out results,
out diagnosticInfos);
if (results.Count != count)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
}
DateTime finish = DateTime.UtcNow;
long totalTicks = finish.Ticks - start.Ticks;
decimal averageMilliseconds = ((((decimal)totalTicks) / ((decimal)result.Iterations))) / ((decimal)TimeSpan.TicksPerMillisecond);
result.Results[requestSizes[ii]] = (double)averageMilliseconds;
}
}
finally
{
TestComplete(result);
}
}
