public CCTrayProject[] GetProjectList(BuildServer server, bool newServer)
{
if (newServer)
{
// Clear the cache when adding a new server
clientFactory.ResetCache(server.Url);
}
ICruiseServerManager manager;
switch (server.Transport)
{
case BuildServerTransport.Remoting:
{
var client = GenerateRemotingClient(server);
manager = new RemotingCruiseServerManager(client, server);
break;
}
case BuildServerTransport.Extension:
return new ExtensionTransportProjectListRetriever(server.ExtensionName).GetProjectList(server);
default:
{
var client = GenerateHttpClient(server);
manager = new HttpCruiseServerManager(client, server);
break;
}
}
if (!string.IsNullOrEmpty(server.SecurityType))
{
manager.Login();
}
return manager.GetProjectList();
}
public void SetUp()
{
serverClient = mocks.DynamicMock<CruiseServerClientBase>();
buildServer = new BuildServer(SERVER_URL);
manager = new HttpCruiseServerManager(serverClient, buildServer);
}
public CCTrayProject(string serverUrl, string projectName)
{
buildServer = new BuildServer(serverUrl);
ServerUrl = serverUrl;
ProjectName = projectName;
showProject = true;
}
public void SetUp()
{
cruiseManagerMock = mocks.StrictMock<CruiseServerClientBase>();
buildServer = new BuildServer(ServerUrl);
manager = new RemotingCruiseServerManager(cruiseManagerMock, buildServer);
}
public CCTrayProject(string serverUrl, string projectName)
{
buildServer = new BuildServer(serverUrl);
ServerUrl = serverUrl;
ProjectName = projectName;
showProject = true;
}
public StubServerMonitor( string serverUrl )
{
this.serverUrl = serverUrl;
BuildServer buildServer = new BuildServer(serverUrl);
this.displayName = buildServer.DisplayName;
this.buildServerTransport = buildServer.Transport;
}
public HttpCruiseServerManager(CruiseServerClientBase manager,
BuildServer buildServer)
{
this.manager = manager;
this.configuration = buildServer;
displayName = GetDisplayNameFromUri(buildServer.Uri);
}
public CCTrayProject[] GetProjectList(ThoughtWorks.CruiseControl.CCTrayLib.Configuration.BuildServer server)
{
List <CCTrayProject> projectsList = new List <CCTrayProject>();
projectsList.Add(new CCTrayProject(server, "Test project #1"));
return(projectsList.ToArray());
}
public TeamCityManager(BuildServer buildServer, HttpClient httpClient, ISirenOfShameManager sosManager)
{
DisplayName = "TeamCityManager";
Configuration = buildServer;
_sosManager = sosManager;
_httpClient = httpClient;
_httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
}
/// <summary>
/// Initialises the args.
/// </summary>
/// <param name="addedProjects"></param>
/// <param name="deletedProjects"></param>
public ServerSnapshotChangedEventArgs(string server,
BuildServer configuration,
IEnumerable<string> addedProjects,
IEnumerable<string> deletedProjects)
{
this.Server = server;
this.Configuration = configuration;
this.addedProjects.AddRange(addedProjects ?? new string[0]);
this.deletedProjects.AddRange(deletedProjects ?? new string[0]);
}
public override bool Equals(object obj)
{
BuildServer other = obj as BuildServer;
if (other == null)
{
return(false);
}
return(other.url.Equals(url));
}
public void WhenRequestingACruiseServerManagerWithAnExtensionProtocolCannotFindExtension()
{
var mockCruiseManagerFactory = mocks.StrictMock<ICruiseServerClientFactory>();
var factory = new CruiseServerManagerFactory(mockCruiseManagerFactory);
var server = new BuildServer("http://somethingOrOther", BuildServerTransport.Extension,
"Extension.Unknown,Extension", string.Empty);
mocks.ReplayAll();
Assert.That(delegate { factory.Create(server); }, Throws.TypeOf<CCTrayLibException>());
}
/// <summary>
/// Generates a set of <see cref="ClientStartUpSettings"/>.
/// </summary>
/// <param name="server"></param>
/// <returns></returns>
public static ClientStartUpSettings GenerateStartupSettings(BuildServer server)
{
var extSettings = server.ExtensionSettings ?? string.Empty;
if (extSettings.Length < 6) extSettings += new string(' ', 6 - extSettings.Length);
var settings = new ClientStartUpSettings
{
BackwardsCompatable = (extSettings.Substring(0, 3) == "OLD"),
UseEncryption = (extSettings.Substring(3, 3) == "SEC")
};
return settings;
}
public TFSServerManager(BuildServer buildServer)
{
if (buildServer.Transport != BuildServerTransport.Extension ||
String.IsNullOrEmpty(buildServer.ExtensionSettings))
{
throw new ArgumentException("You must specify the TFS Settings to utilize this Server Manager");
}
_buildServer = buildServer;
Settings = TFSServerManagerSettings.GetSettings(buildServer.ExtensionSettings);
}
public void WhenRequestingACruiseServerManagerWithAnExtensionProtocolEmptyExtension()
{
var mockCruiseManagerFactory = mocks.StrictMock<ICruiseServerClientFactory>();
var factory = new CruiseServerManagerFactory(mockCruiseManagerFactory);
var server = new BuildServer("http://somethingOrOther", BuildServerTransport.Extension, "New Extension", string.Empty);
server.ExtensionName = null;
mocks.ReplayAll();
Assert.That(delegate { factory.Create(server); },
Throws.TypeOf<ArgumentOutOfRangeException>().With.Property("ParamName").EqualTo("name"));
}
public void Setup()
{
var settings = new Settings()
{
Project = String.Empty,
Username = String.Empty,
Password = String.Empty,
Server = "https://builds.apache.org/"
};
var buildServer = new BuildServer(settings.Server);
Manager = new JenkinsProjectManager(new WebRequestFactory(), new JenkinsApiFactory());
Manager.Initialize(buildServer, "Hadoop-1-win", settings);
}
public ISingleServerMonitor[] GetServerMonitors()
{
BuildServer[] buildServers = GetUniqueBuildServerList();
ISingleServerMonitor[] serverMonitors = new ISingleServerMonitor[buildServers.Length];
for (int i = 0; i < buildServers.Length; i++)
{
BuildServer buildServer = buildServers[i];
ICruiseServerManager serverManager = cruiseServerManagerFactory.Create(buildServer);
serverManagersList[buildServer] = serverManager;
serverMonitors[i] = new ServerMonitor(serverManager);
}
return(serverMonitors);
}
public void WhenRequestingACruiseProjectManagerWithAnExtensionProtocolValidExtension()
{
var server = new BuildServer("http://somethingOrOther", BuildServerTransport.Extension, "ThoughtWorks.CruiseControl.UnitTests.CCTrayLib.Monitoring.ExtensionProtocolStub,ThoughtWorks.CruiseControl.UnitTests",string.Empty);
var mockCruiseManagerFactory = mocks.StrictMock<ICruiseServerClientFactory>();
var factory = new CruiseProjectManagerFactory(mockCruiseManagerFactory);
var serverManagers = new Dictionary<BuildServer, ICruiseServerManager>();
mocks.ReplayAll();
var manager = factory.Create(new CCTrayProject(server, ProjectName), serverManagers);
Assert.AreEqual(ProjectName, manager.ProjectName);
mocks.VerifyAll();
}
/// <summary>
/// Construct a unique list of the build servers based on the projects configured in CCTray.
/// </summary>
/// <returns></returns>
public BuildServer[] GetUniqueBuildServerList()
{
ArrayList buildServerList = new ArrayList();
for (int i = 0; i < Projects.Length; i++)
{
BuildServer buildServer = Projects[i].BuildServer;
if (!buildServerList.Contains(buildServer))
{
buildServerList.Add(buildServer);
}
}
return((BuildServer[])buildServerList.ToArray(typeof(BuildServer)));
}
public bool Configure(IWin32Window owner)
{
var config = new Configuration();
if(Configuration != null)
config.BaseUrl = Configuration.Url;
config.ShowDialog(owner);
if (config.DialogResult == DialogResult.OK)
{
Configuration = new BuildServer(FormatBaseUrl(config.BaseUrl), BuildServerTransport.Extension, DisplayName,
string.Empty);
}
return true;
}
public ConfigureServer(BuildServer server)
{
InitializeComponent();
this.server = server;
Text = "Configure server: " + server.DisplayName;
LoadModes();
if (server.SecurityType != null)
{
chkIsSecure.Checked = true;
for (int loop = 0; loop < cmbAuthMode.Items.Count; loop++)
{
ExtensionDetails details = (ExtensionDetails)cmbAuthMode.Items[loop];
if (details.TypeName == server.SecurityType) cmbAuthMode.SelectedIndex = loop;
}
}
}
public void WhenRequestingACruiseServerManagerWithATCPUrlAsksTheCruiseManagerFactory()
{
var serverAddress = @"tcp://1.2.3.4";
var server = new BuildServer(serverAddress);
var mockCruiseManagerFactory = mocks.StrictMock<ICruiseServerClientFactory>();
var factory = new CruiseServerManagerFactory(mockCruiseManagerFactory);
var client = mocks.DynamicMock<CruiseServerClientBase>();
Expect.Call(mockCruiseManagerFactory.GenerateRemotingClient(serverAddress, new ClientStartUpSettings()))
.Constraints(new Equal(serverAddress), new Anything())
.Return(client);
mocks.ReplayAll();
var manager = factory.Create(server);
Assert.AreEqual(server.Url, manager.Configuration.Url);
Assert.AreEqual(typeof (CachingCruiseServerManager), manager.GetType());
mocks.VerifyAll();
}
public void WhenRequestingACruiseServerManagerWithAnHttpUrlConstructsANewHttpServerManagerDecoratedWithACachingServerManager()
{
var mockCruiseManagerFactory = mocks.StrictMock<ICruiseServerClientFactory>();
var factory = new CruiseServerManagerFactory(mockCruiseManagerFactory);
var serverAddress = "http://somethingOrOther";
var server = new BuildServer(serverAddress);
var client = mocks.DynamicMock<CruiseServerClientBase>();
Expect.Call(mockCruiseManagerFactory.GenerateHttpClient(serverAddress, new ClientStartUpSettings()))
.Constraints(new Equal(serverAddress), new Anything())
.Return(client);
mocks.ReplayAll();
var manager = factory.Create(server);
Assert.AreEqual(server.Url, manager.Configuration.Url);
Assert.AreEqual(typeof (CachingCruiseServerManager), manager.GetType());
mocks.VerifyAll();
}
public ICruiseServerManager Create(BuildServer buildServer)
{
switch (buildServer.Transport)
{
case BuildServerTransport.Remoting:
{
var manager = GenerateRemotingClient(buildServer);
return new CachingCruiseServerManager(new RemotingCruiseServerManager(manager, buildServer));
}
case BuildServerTransport.Extension:
ITransportExtension extensionInstance = ExtensionHelpers.RetrieveExtension(buildServer.ExtensionName);
extensionInstance.Settings = buildServer.ExtensionSettings;
extensionInstance.Configuration = buildServer;
return extensionInstance.RetrieveServerManager();
default:
{
var manager = GenerateHttpClient(buildServer);
return new CachingCruiseServerManager(
new HttpCruiseServerManager(manager, buildServer));
}
}
}
public void WhenRequestingACruiseProjectManagerWithAnHttpUrlConstructsANewDashboardCruiseProjectManager()
{
var serverAddress = "http://somethingOrOther";
var server = new BuildServer(serverAddress);
var client = mocks.DynamicMock<CruiseServerClientBase>();
var clientFactory = mocks.StrictMock<ICruiseServerClientFactory>();
Expect.Call(clientFactory.GenerateHttpClient(serverAddress, new ClientStartUpSettings()))
.Constraints(new Equal(serverAddress), new Anything())
.Return(client);
var factory = new CruiseProjectManagerFactory(clientFactory);
var serverManagers = new Dictionary<BuildServer, ICruiseServerManager>();
serverManagers[server] = new HttpCruiseServerManager(client, server);
mocks.ReplayAll();
var manager = factory.Create(new CCTrayProject(server, ProjectName), serverManagers);
Assert.AreEqual(ProjectName, manager.ProjectName);
Assert.AreEqual(typeof(HttpCruiseProjectManager), manager.GetType());
mocks.VerifyAll();
}
private void RetrieveListOfProjects(BuildServer server)
{
Cursor.Current = Cursors.WaitCursor;
try
{
lbProject.Items.Clear();
CCTrayProject[] projectList = cruiseProjectManagerFactory.GetProjectList(server, false);
foreach (CCTrayProject project in projectList)
{
if (! IsProjectAlreadyAdded(project))
lbProject.Items.Add(project.ProjectName);
}
}
catch (Exception ex)
{
MessageBox.Show(this, "Unable to connect to server " + server.DisplayName + ": " + ex.Message, "Error");
}
finally
{
Cursor.Current = Cursors.Default;
}
}
public void GetProjectListWithAnExtensionProtocolValidExtension()
{
var server = new BuildServer("http://somethingOrOther", BuildServerTransport.Extension, "ThoughtWorks.CruiseControl.UnitTests.CCTrayLib.Monitoring.ExtensionProtocolStub,ThoughtWorks.CruiseControl.UnitTests",string.Empty);
var mockCruiseManagerFactory = mocks.StrictMock<ICruiseServerClientFactory>();
var factory = new CruiseProjectManagerFactory(mockCruiseManagerFactory);
mocks.ReplayAll();
CCTrayProject[] projectList = factory.GetProjectList(server, false);
Assert.AreNotEqual(0, projectList.Length);
mocks.VerifyAll();
}
public CCTrayProject()
{
buildServer = new BuildServer();
showProject = true;
}
public CCTrayProject(BuildServer buildServer, string projectName)
{
this.buildServer = buildServer;
this.projectName = projectName;
showProject = true;
}
public CCTrayProject[] GetProjectList(BuildServer server)
{
var manager = (IJenkinsServerManager)RetrieveServerManager();
manager.SetConfiguration(server);
// If we are getting the project list, then we should reset the ServerManager's project list
// It will be reset when we return to the list
manager.ProjectsAndCurrentStatus.Clear();
return manager.GetProjectList();
}
public bool Configure(IWin32Window owner)
{
using (var form = ConfigurationFormFactory.Create())
{
if (form.ShowDialog(owner) == DialogResult.OK)
{
var server = form.GetServer();
Configuration = new BuildServer(server);
var settings = new Settings()
{
Project = String.Empty,
Server = server,
Username = form.GetUsername(),
Password = form.GetPassword()
};
Settings = settings.ToString();
//We will need to initialize the server manager again if their information has changed
JenkinsServerManagerFactory.IsServerManagerInitialized = false;
return true;
}
return false;
}
}
public void TestSetConfiguration()
{
var buildServer = new BuildServer("http://test.com");
Manager.SetConfiguration(buildServer);
Assert.AreEqual(Manager.Configuration.Url, "http://test.com");
}
public void TestLoginAndLogout()
{
var settings = new Settings()
{
Project = String.Empty,
Username = "******",
Password = "******",
Server = "https://builds.apache.org/"
};
var buildServer = new BuildServer(settings.Server);
Manager.Initialize(buildServer, String.Empty, settings);
Manager.Login();
Assert.IsFalse(String.IsNullOrEmpty(Manager.AuthorizationInformation));
Manager.Logout();
Assert.IsTrue(String.IsNullOrEmpty(Manager.AuthorizationInformation));
}
public static bool Configure(IWin32Window parent, BuildServer server)
{
ConfigureServer configureDialog = new ConfigureServer(server);
bool hasChanged = (configureDialog.ShowDialog(parent) == DialogResult.OK);
return hasChanged;
}
private BuildServer ConstructBuildServerFromSelectedOptions()
{
if (rdoRemoting.Checked)
{
var server = BuildServer.BuildFromRemotingDisplayName(txtRemoting.Text);
server.ExtensionSettings = ClientStartUpSettingsExtensions.GenerateExtensionSettings(connectToOldServer.Checked,
remotingEncryption.Checked);
return server;
}
if (rdoHttp.Checked)
{
var server = new BuildServer(txtHttp.Text);
server.ExtensionSettings = ClientStartUpSettingsExtensions.GenerateExtensionSettings(true, false);
return server;
}
if (rdoDashboard.Checked)
{
var baseUri = txtDashboard.Text;
if (baseUri.EndsWith("XmlStatusReport.aspx", StringComparison.CurrentCultureIgnoreCase) ||
baseUri.EndsWith("XmlServerReport.aspx", StringComparison.CurrentCultureIgnoreCase))
{
baseUri = baseUri.Substring(0, baseUri.Length - 20);
}
var server = new BuildServer(baseUri);
server.ExtensionSettings = ClientStartUpSettingsExtensions.GenerateExtensionSettings(connectToOldDashboard.Checked,
httpEncryption.Checked);
return server;
}
if (rdoExtension.Checked)
{
if (transportExtension == null) throw new ApplicationException("No extension selected");
var server = new BuildServer(transportExtension.Configuration.Url,
BuildServerTransport.Extension,
cmbExtension.Text,
transportExtension.Settings);
return server;
}
return null;
}
private void ValidateConnection(BuildServer server)
{
cruiseProjectManagerFactory.GetProjectList(server, true);
}
private void btnOK_Click(object sender, EventArgs e)
{
buildServer = null;
txtFeedback.Visible = true;
txtFeedback.Text = "Validating...";
Refresh();
try
{
buildServer = ConstructBuildServerFromSelectedOptions();
ValidateConnection(buildServer);
DialogResult = DialogResult.OK;
Hide();
}
catch (Exception ex)
{
txtFeedback.Text = "Failed to connect to server: " + ex.Message;
}
}
