public void setNewSessionRequest(NewSessionRequest nsr)
{
if (nsr.SessionTemplate != null)
{
// use the session controller to find the session as the objects held
// held in the session control may not be the same
sessionComboBox.SelectedItem = sc.findSession(nsr.SessionTemplate);
if (nsr.SessionFolder == null)
{
sessionFolderComboBox.SelectedItem = nsr.SessionTemplate.FolderName;
}
else
{
sessionFolderComboBox.SelectedItem = nsr.SessionFolder;
}
}
else
{
sessionComboBox.SelectedItem = sc.findDefaultSession(false);
if (nsr.SessionFolder != null && !(nsr.SessionFolder.Equals("")))
{
sessionFolderComboBox.SelectedItem = nsr.SessionFolder;
}
}
launchSessionCheckBox.Checked = nsr.LaunchSession;
copyUsernameCheckBox.Checked = nsr.CopyDefaultUsername;
}
protected void newSession(List <Session> selectedSessions)
{
if (selectedSessions.Count > 0)
{
// Pick the first selected session to be the template
Session template = selectedSessions[0];
NewSessionRequest nsr = new NewSessionRequest(template, template.FolderName, "", "", true, false);
nsf.setNewSessionRequest(nsr);
}
if (nsf.ShowDialog() == DialogResult.OK)
{
NewSessionRequest nsr = nsf.getNewSessionRequest();
bool result = sc.createNewSession(nsr, this);
if (result == false)
{
MessageBox.Show("Failed to create new session: " + nsr.SessionName
, "Alert", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
if (nsr.LaunchSession == true)
{
String errMsg = sc.launchSession(nsr.SessionName);
if (errMsg.Equals("") == false)
{
MessageBox.Show("PuTTY Failed to start.\nCheck the PuTTY location in System Tray -> Options.\n" +
errMsg
, "Alert", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
}
}
public override Task <NewSessionReply> OpenSession(NewSessionRequest request, ServerCallContext context)
{
Console.WriteLine($"SPRO OpenSession for {request.Username} / {request.Type}");
string idSession = "";
if (request.Type != null && (_sessionsType == null || _sessionsType == request.Type))
{
_sessionsType = request.Type;
var userTimer = new Timer(Config.TIMEOUT);
lock (_lock)
{
if (_usersInSession.Count < Config.MAX_USER_COUNT &&
_usersInSession.TryAdd(request.Username, userTimer))
{
idSession = Guid.NewGuid().ToString();
userTimer.Start();
userTimer.Elapsed += (object sender, ElapsedEventArgs e) =>
{
//RemoveUser(request.Username);
};
_initTimeout.Stop();
Console.WriteLine($"SPRO OpenSession for {request.Username} / {request.Type} GRANTED {idSession}");
}
}
}
return(Task.FromResult(new NewSessionReply {
Idsession = idSession
}));
}
public object Post(NewSessionRequest request)
{
if (request.RequiredCapabilities != null)
{
// TODO: verify that required capabilities can be supported, otherwise return session_not_created
}
if (request.DesiredCapabilities != null)
{
// TODO: verify that app exists, otherwise return session_not_created
// TODO: support more desired capabilities, rather than just ignoring them
var capabilities = new Capabilities(request.DesiredCapabilities);
var session = _sessionRepository.Create(capabilities);
return(new HttpResult
{
StatusCode = HttpStatusCode.RedirectMethod,
Headers =
{
{ HttpHeaders.Location, RequestContext.AbsoluteUri.WithTrailingSlash() + session.SessionId.ToString("N") }
}
});
}
throw new MissingCommandParameterException();
}
public async Task CreateSession_HandlesError_Async()
{
var sessionClient = new Mock <NamespacedKubernetesClient <WebDriverSession> >(MockBehavior.Strict);
var kubernetes = new Mock <KubernetesClient>(MockBehavior.Strict);
kubernetes.Setup(c => c.GetClient <WebDriverSession>()).Returns(sessionClient.Object);
var webDriver = new KubernetesWebDriver(kubernetes.Object, NullLogger <KubernetesWebDriver> .Instance);
var request = new NewSessionRequest()
{
Capabilities = new CapabilitiesRequest()
{
AlwaysMatch = new Dictionary <string, object>()
{
{ "platformName", "fake" },
},
},
};
var session = new WebDriverSession()
{
Metadata = new V1ObjectMeta()
{
Name = "fake-abcd",
},
};
sessionClient
.Setup(s => s.CreateAsync(It.IsAny <WebDriverSession>(), default))
.ReturnsAsync(session);
var watchHook = sessionClient.WithWatcher(session);
var task = webDriver.CreateSessionAsync(request, default);
var watchClient = await watchHook.ClientRegistered.Task.ConfigureAwait(false);
// Simulate the session going through the various stages of setup
session.Status = new WebDriverSessionStatus()
{
Error = "error",
Data = "data",
Message = "message",
StackTrace = "stacktrace",
};
Assert.Equal(WatchResult.Stop, await watchClient(k8s.WatchEventType.Modified, session).ConfigureAwait(false));
sessionClient.Setup(s => s.TryReadAsync(session.Metadata.Name, default)).ReturnsAsync(session);
sessionClient.Setup(s => s.DeleteAsync(session, It.IsAny <TimeSpan>(), default)).Returns(Task.CompletedTask);
watchHook.TaskCompletionSource.SetResult(WatchExitReason.ClientDisconnected);
var result = await task.ConfigureAwait(false);
var response = Assert.IsType <WebDriverError>(result.Value);
Assert.Equal(WebDriverErrorCode.SessionNotCreated, response.ErrorCode);
Assert.Equal("data", response.Data);
Assert.Equal("message", response.Message);
Assert.Equal("stacktrace", response.StackTrace);
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
/// <returns></returns>
public int syncSessions(BackgroundWorker worker, SyncSessionsRequestedEventArgs e)
{
int modifiedCount = 0;
List <Session> delList = new List <Session>();
// Disable session refreshes
BeginUpdate();
foreach (SessionAction sa in e.SessionActionList)
{
if (sa.Action == SessionAction.ACTION.ADD)
{
NewSessionRequest nsr = new NewSessionRequest(e.SessionTemplate
, sa.NewSession.FolderName
, sa.NewSession.Hostname
, sa.NewSession.SessionDisplayText
, sa.NewSession.Protocol
, sa.NewSession.Portnumber
, true, false);
createNewSession(nsr, worker);
}
else if (sa.Action == SessionAction.ACTION.DELETE)
{
delList.Add(sa.ExistingSession);
}
else if (sa.Action == SessionAction.ACTION.UPDATE)
{
Session existingSession = findSession(sa.NewSession);
if (existingSession != null)
{
sessionProvider.updateHostname(sa.NewSession);
sessionProvider.updateFolder(sa.NewSession);
sessionProvider.updateProtocol(sa.NewSession);
sessionProvider.updatePortnumber(sa.NewSession);
}
}
else if (sa.Action == SessionAction.ACTION.RENAME)
{
Session existingSession = findSession(sa.ExistingSession);
sessionProvider.renameSession(existingSession, sa.NewSession.SessionDisplayText);
existingSession.FolderName = sa.NewSession.FolderName;
sessionProvider.updateFolder(existingSession);
}
modifiedCount++;
worker.ReportProgress(modifiedCount);
}
if (delList.Count > 0)
{
deleteSessions(delList, worker);
}
worker.ReportProgress(e.SessionActionList.Count);
// Re-enable session refreshes
EndUpdate();
return(modifiedCount);
}
private void NoveSoubory(object s, NoveSouboryEventArgs e)
{
NewSessionRequest newSessionRequest = new NewSessionRequest();
newSessionRequest.Soubory = e.Soubory;
newSessionRequest.RowTemplate = rowTemplates.FirstOrDefault(t => t.Nazev == e.Vzor) ?? throw new IndexOutOfRangeException($"V listu všech vzorů nebyl nalezen tempalte s nazvem{e.Vzor}");
commandHandler.Handle(newSessionRequest);
}
public GlobalJsonResult <bool> NewSession([FromBody] NewSessionRequest request)
{
var client = request.Map();
clientStore.Set(client);
return(GlobalJsonResult <bool> .Success(System.Net.HttpStatusCode.OK, true));
}
/// <summary>
/// Create a new session based on an existing session
/// Delegates to the sessionProvider, and then
/// fires a session refresh event
/// </summary>
/// <param name="nsr">The new session request</param>
/// <param name="sender"></param>
/// <returns></returns>
public bool createNewSession(NewSessionRequest nsr, Object sender)
{
bool result = sessionProvider.createNewSession(nsr);
// Don't refresh the sender - this should have done it's own update
invalidateSessionList(sender, false);
return(result);
}
public NewSessionRequest getNewSessionRequest()
{
NewSessionRequest nsr = new NewSessionRequest((Session)sessionComboBox.SelectedItem
, sessionFolderComboBox.Text
, hostnameTextBox.Text
, sessionnameTextBox.Text
, copyUsernameCheckBox.Checked
, launchSessionCheckBox.Checked);
return(nsr);
}
public async Task CreateSessionAsync_InvalidCapabilities_Async(NewSessionRequest request, string expectedMessage)
{
var kubernetes = new Mock <KubernetesClient>();
var webDriver = new KubernetesWebDriver(kubernetes.Object, NullLogger <KubernetesWebDriver> .Instance);
var result = await webDriver.CreateSessionAsync(request, default).ConfigureAwait(false);
var error = Assert.IsType <WebDriverError>(result.Value);
Assert.Equal(WebDriverErrorCode.SessionNotCreated, error.ErrorCode);
Assert.Equal(expectedMessage, error.Message);
}
public async Task NewSessionAsync_InvokesDriver_Async()
{
var request = new NewSessionRequest();
var response = new WebDriverResponse();
var webDriver = new Mock <KubernetesWebDriver>(MockBehavior.Strict);
webDriver
.Setup(w => w.CreateSessionAsync(request, default))
.ReturnsAsync(response);
var controller = new WebDriverController(webDriver.Object, NullLogger <WebDriverController> .Instance);
var result = await controller.NewSessionAsync(request, default).ConfigureAwait(false);
Assert.Same(response, result.Value);
}
public async Task CreateSession_TimesOut_Async()
{
var sessionClient = new Mock <NamespacedKubernetesClient <WebDriverSession> >(MockBehavior.Strict);
var kubernetes = new Mock <KubernetesClient>(MockBehavior.Strict);
kubernetes.Setup(c => c.GetClient <WebDriverSession>()).Returns(sessionClient.Object);
var webDriver = new KubernetesWebDriver(kubernetes.Object, NullLogger <KubernetesWebDriver> .Instance);
webDriver.CreationTimeout = TimeSpan.FromMilliseconds(10);
var request = new NewSessionRequest()
{
Capabilities = new CapabilitiesRequest()
{
AlwaysMatch = new Dictionary <string, object>()
{
{ "platformName", "fake" },
},
},
};
var session = new WebDriverSession()
{
Metadata = new V1ObjectMeta()
{
Name = "fake-abcd",
},
};
sessionClient
.Setup(s => s.CreateAsync(It.IsAny <WebDriverSession>(), default))
.ReturnsAsync(session);
var watchHook = sessionClient.WithWatcher(session);
var task = webDriver.CreateSessionAsync(request, default);
var watchClient = await watchHook.ClientRegistered.Task.ConfigureAwait(false);
var result = await task.ConfigureAwait(false);
var response = Assert.IsType <WebDriverError>(result.Value);
Assert.Equal(WebDriverErrorCode.SessionNotCreated, response.ErrorCode);
Assert.Equal("The session creation timed out.", response.Message);
}
/// <summary>
/// Create a new session based on an old session
/// </summary>
/// <param name="nsr">The new session request</param>
/// <returns></returns>
public bool createNewSession(NewSessionRequest nsr)
{
// Check the template session is still there
RegistryKey template = Registry.CurrentUser.OpenSubKey(PUTTY_SESSIONS_REG_KEY + "\\" + nsr.SessionTemplate.SessionKey, false);
if (template == null)
{
return(false);
}
// Check no-one has created a new session with the same name
RegistryKey newSession = Registry.CurrentUser.OpenSubKey(PUTTY_SESSIONS_REG_KEY + "\\" + nsr.SessionName, false);
if (newSession != null)
{
newSession.Close();
return(false);
}
// Create the new session
newSession = Registry.CurrentUser.CreateSubKey(PUTTY_SESSIONS_REG_KEY + "\\" + Session.convertDisplayToSessionKey(nsr.SessionName));
// Copy the values
bool hostnameSet = false;
bool foldernameSet = false;
bool protocolSet = false;
bool portnumberSet = false;
object value;
foreach (string valueName in template.GetValueNames())
{
if (valueName.Equals(PUTTY_HOSTNAME_ATTRIB))
{
hostnameSet = true;
value = nsr.Hostname;
}
else if (valueName.Equals(PUTTY_PSM_FOLDER_ATTRIB))
{
foldernameSet = true;
value = nsr.SessionFolder;
}
else if (nsr.CopyDefaultUsername == false &&
valueName.Equals(PUTTY_USERNAME_ATTRIB))
{
value = "";
}
else if (valueName.Equals(PUTTY_PROTOCOL_ATTRIB) &&
!(nsr.Protocol.Equals("")))
{
protocolSet = true;
value = nsr.Protocol;
}
else if (valueName.Equals(PUTTY_PORTNUMBER_ATTRIB) &&
nsr.Portnumber > 0)
{
portnumberSet = true;
value = nsr.Portnumber;
}
else
{
value = template.GetValue(valueName);
}
newSession.SetValue(valueName, value, template.GetValueKind(valueName));
}
// Set the hostname if it hasn't already been set
if (hostnameSet == false)
{
newSession.SetValue(PUTTY_HOSTNAME_ATTRIB, nsr.Hostname, RegistryValueKind.String);
}
// Set the foldername if it hasn't already been set
if (foldernameSet == false)
{
newSession.SetValue(PUTTY_PSM_FOLDER_ATTRIB, nsr.SessionFolder, RegistryValueKind.String);
}
// Set the protocol if it hasn't already been set
if (protocolSet == false)
{
newSession.SetValue(PUTTY_PROTOCOL_ATTRIB, nsr.Protocol, RegistryValueKind.String);
}
// Set the portnumber if it hasn't already been set
if (portnumberSet == false)
{
newSession.SetValue(PUTTY_PORTNUMBER_ATTRIB, nsr.Portnumber, RegistryValueKind.DWord);
}
template.Close();
newSession.Close();
return(true);
}
public async Task <WebDriverResult> NewSessionAsync(NewSessionRequest request, CancellationToken cancellationToken)
{
var response = await this.webDriver.CreateSessionAsync(request, cancellationToken).ConfigureAwait(false);
return(new WebDriverResult(response));
}
public async Task CreateSession_CreatesSession_Async(string platformName, string automationName, string providerName)
{
var sessionClient = new Mock <NamespacedKubernetesClient <WebDriverSession> >(MockBehavior.Strict);
var kubernetes = new Mock <KubernetesClient>(MockBehavior.Strict);
kubernetes.Setup(c => c.GetClient <WebDriverSession>()).Returns(sessionClient.Object);
var webDriver = new KubernetesWebDriver(kubernetes.Object, NullLogger <KubernetesWebDriver> .Instance);
var request = new NewSessionRequest()
{
Capabilities = new CapabilitiesRequest()
{
AlwaysMatch = new Dictionary <string, object>()
{
{ "platformName", platformName },
{ "appium:automationName", automationName },
},
},
};
var session = new WebDriverSession()
{
Metadata = new V1ObjectMeta()
{
Name = "fake-abcd",
},
};
sessionClient
.Setup(s => s.CreateAsync(It.IsAny <WebDriverSession>(), default))
.Returns <WebDriverSession, CancellationToken>((request, ct) =>
{
Assert.Equal($"{providerName}-", request.Metadata.GenerateName);
Assert.Collection(
request.Metadata.Labels,
l =>
{
Assert.Equal(Annotations.AutomationName, l.Key);
Assert.Equal(providerName, l.Value);
});
if (automationName != null)
{
Assert.Equal($"{{\"alwaysMatch\":{{\"platformName\":\"{platformName}\",\"appium:automationName\":\"{automationName}\"}}}}", request.Spec.Capabilities);
}
else
{
Assert.Equal($"{{\"alwaysMatch\":{{\"platformName\":\"{platformName}\",\"appium:automationName\":null}}}}", request.Spec.Capabilities);
}
return(Task.FromResult(session));
});
var watchHook = sessionClient.WithWatcher(session);
var task = webDriver.CreateSessionAsync(request, default);
var watchClient = await watchHook.ClientRegistered.Task.ConfigureAwait(false);
// Simulate the session going through the various stages of setup
Assert.Equal(WatchResult.Continue, await watchClient(k8s.WatchEventType.Added, session).ConfigureAwait(false));
Assert.Equal(WatchResult.Continue, await watchClient(k8s.WatchEventType.Modified, session).ConfigureAwait(false));
Assert.Equal(WatchResult.Continue, await watchClient(k8s.WatchEventType.Bookmark, session).ConfigureAwait(false));
session.Status = new WebDriverSessionStatus()
{
IngressReady = false,
ServiceReady = false,
SessionReady = false,
};
Assert.Equal(WatchResult.Continue, await watchClient(k8s.WatchEventType.Modified, session).ConfigureAwait(false));
session.Status.IngressReady = true;
Assert.Equal(WatchResult.Continue, await watchClient(k8s.WatchEventType.Modified, session).ConfigureAwait(false));
session.Status.SessionReady = true;
session.Status.Capabilities = "{}";
Assert.Equal(WatchResult.Continue, await watchClient(k8s.WatchEventType.Modified, session).ConfigureAwait(false));
session.Status.ServiceReady = true;
Assert.Equal(WatchResult.Stop, await watchClient(k8s.WatchEventType.Modified, session).ConfigureAwait(false));
sessionClient.Setup(s => s.TryReadAsync(session.Metadata.Name, default)).ReturnsAsync(session);
watchHook.TaskCompletionSource.SetResult(WatchExitReason.ClientDisconnected);
var result = await task.ConfigureAwait(false);
var response = Assert.IsType <NewSessionResponse>(result.Value);
Assert.Equal("fake-abcd", response.SessionId);
Assert.Empty(response.Capabilities);
}
