public Wallboard()
{
InitializeComponent();
teamFoundationServer.Authenticate();
VersionControlServer s = (VersionControlServer)teamFoundationServer.GetService(typeof(VersionControlServer));
}
public ChangesetInfo(string tfsServer, KnownFileTypes knownFileTypes)
{
if (string.IsNullOrWhiteSpace(tfsServer))
{
throw new ArgumentNullException("tfsServer", "tfsServer is required");
}
_tfs = Server.GetTfsServer(tfsServer);
_versionControl = _tfs.GetService(typeof(VersionControlServer)) as VersionControlServer;
_workItemStore = (WorkItemStore)_tfs.GetService(typeof(WorkItemStore));
this.Downloader = new WorkItemFileManager(knownFileTypes);
}
static void Main(string[] args)
{
// Let the user choose a TFS Server.
Console.Write("Please enter a valid TFS Server or URI: ");
String tfsServer = Console.ReadLine();
tfsServer = tfsServer.Trim();
// Connect to the TeamFoundationServer.
Console.WriteLine();
Console.Write("Connecting to Team Foundation Server {0}...", tfsServer);
TeamFoundationServer tfs =
TeamFoundationServerFactory.GetServer(tfsServer);
// Connect to the WorkItemStore.
Console.WriteLine();
Console.Write("Reading from the Work Item Store...");
WorkItemStore workItemStore = (WorkItemStore)tfs.GetService(typeof(WorkItemStore));
// Display the details about the TeamFoundationServer.
Console.WriteLine("\n");
Console.WriteLine("Team Foundation Server details");
Console.WriteLine("Server Name: " + tfs.Name);
Console.WriteLine("Uri: " + tfs.Uri);
Console.WriteLine("AuthenticatedUserDisplayName: " + tfs.AuthenticatedUserDisplayName);
Console.WriteLine("AuthenticatedUserName: "******"WorkItemStore:");
// List the Projects in the WorkItemStore.
Console.WriteLine(" Projects.Count: " + workItemStore.Projects.Count);
foreach (Project pr in workItemStore.Projects)
{
Console.WriteLine(" " + pr.Name);
}
}
public VersionControlServer GetVersionControlServer(string url)
{
ICredentials creds = GetCredentials(url);
TeamFoundationServer tfs = TeamFoundationServerFactory.GetServer(url, creds);
return(tfs.GetService(typeof(VersionControlServer)) as VersionControlServer);
}
internal static Identity ResolveUser(VSTSConnection vstsConn, string userName)
{
Debug.Assert(vstsConn != null, "Null vstsConn handle");
Debug.Assert(userName != null, "Null userName param");
if (m_gss == null)
{
TeamFoundationServer tfs = TeamFoundationServerFactory.GetServer(vstsConn.bisUri);
m_gss = (IGroupSecurityService)tfs.GetService(typeof(IGroupSecurityService));
}
// Get the user identity
Identity userIdentity = null;
try
{
userIdentity = m_gss.ReadIdentityFromSource(SearchFactor.AccountName, userName);
}
catch (Exception ex)
{
// if there is some Active Directory issue, currently GSS throws GroupSecuritySubsystemException
// bug#57749 plans to give specific exception for this..
// we are handling Exception here as the bug 57749 lists this exception as well
// as one of the possible exception that can be thrown
// for this exception assume that the user cannot be resolved
Logger.Write(LogSource.WorkItemTracking, TraceLevel.Warning, "Could not resolve user {0} because of {1}",
userName, ex.Message);
}
return(userIdentity);
}
public bool Execute()
{
// set up support for logging
TaskLoggingHelper loggingHelper = new TaskLoggingHelper(this);
// Log Variables
loggingHelper.LogMessageFromText("Custom Task QueueBuild Starting", MessageImportance.High);
loggingHelper.LogMessageFromText("tfsServer = " + tfsServer, MessageImportance.High);
loggingHelper.LogMessageFromText("teamProject = " + teamProject, MessageImportance.High);
loggingHelper.LogMessageFromText("buildDefinition = " + buildDefinition, MessageImportance.High);
// Get the team foundation server
TeamFoundationServer tfs = TeamFoundationServerFactory.GetServer(tfsServer);
// Get the IBuildServer
IBuildServer buildServer = (IBuildServer)tfs.GetService(typeof(IBuildServer));
// Get the build definition for which a build is to be queued
IBuildDefinition buildDef = buildServer.GetBuildDefinition(teamProject, buildDefinition);
// Create variable for queuedBuild and queue the build
var queuedBuild = buildServer.QueueBuild(buildDef);
loggingHelper.LogMessageFromText("Waiting for newly queued build from Team Project : " + teamProject + " : and Build Definition : " + buildDefinition + " : to complete", MessageImportance.High);
loggingHelper.LogMessageFromText("Pinging queuedBuild : " + queuedBuild + " : every 5 seconds to confirm when build is complete", MessageImportance.High);
// Wait for the completion of newly queued build - Will ping build every 5 seconds to confirm completion for a max of 5 hours
queuedBuild.WaitForBuildCompletion(TimeSpan.FromSeconds(5), TimeSpan.FromHours(5));
loggingHelper.LogMessageFromText("Queued Build : " + queuedBuild.Build.BuildNumber + " has now completed", MessageImportance.High);
loggingHelper.LogMessageFromText("Returning to original build", MessageImportance.High);
return(true);
}
internal WorkItemThingy(string srvr, string query)
{
_server = TeamFoundationServerFactory.GetServer(srvr);
//_query = query;
_store = _server.GetService(typeof(WorkItemStore)) as WorkItemStore;
}
public void Workspace_GetViaInfo()
{
// need TFS_ envvars for this test
if (String.IsNullOrEmpty(tfsUrl))
{
return;
}
TeamFoundationServer tfs = new TeamFoundationServer(tfsUrl, credentials);
VersionControlServer vcs = (VersionControlServer)tfs.GetService(typeof(VersionControlServer));
WorkingFolder[] folders = new WorkingFolder[1];
string serverItem = String.Format("$/{0}", Environment.GetEnvironmentVariable("TFS_PROJECT"));
folders[0] = new WorkingFolder(serverItem, Environment.CurrentDirectory);
Workspace w1 = vcs.CreateWorkspace("CreateDelete1_Workspace",
Environment.GetEnvironmentVariable("TFS_USERNAME"),
"My Comment", folders, Environment.MachineName);
//Workstation.Current.UpdateWorkspaceInfoCache(vcs, Environment.GetEnvironmentVariable("TFS_USERNAME"));
WorkspaceInfo info = Workstation.Current.GetLocalWorkspaceInfo(Environment.CurrentDirectory);
Workspace w2 = info.GetWorkspace(tfs);
// does info.GetWorkspace talk to the server and get the
// mapped paths or no? ANSWER: NO IT DOESN'T
string serverItem2 = w2.TryGetServerItemForLocalItem("foo.txt");
Assert.AreEqual(null, serverItem2);
w1.Delete();
}
/// <summary>
/// Tries the TFS mode.
/// </summary>
/// <param name="input">The input.</param>
/// <returns>the number of checkedout files</returns>
internal static int TryTFSMode(System.IO.FileInfo input)
{
try
{
var tfs = new TeamFoundationServer(Properties.Settings.Default.TFSServer, new NetworkCredential(Properties.Settings.Default.TFSLogin, Properties.Settings.Default.TFSPassword));
var version = (VersionControlServer)tfs.GetService(typeof(VersionControlServer));
var workspace = version.GetWorkspace(Properties.Settings.Default.TFSWorkspace, version.AuthorizedUser);
int ans = workspace.PendEdit(input.FullName);
return(ans);
}
catch (Exception)
{
Console.WriteLine(
string.Format(
@"
/!\The file {0} is read only
please make sure the TFS app settings are OK
Stack trace:
",
input.FullName));
throw;
}
}
public void FixtureSetUp()
{
tfsUrl = Environment.GetEnvironmentVariable("TFS_URL");
if (String.IsNullOrEmpty(tfsUrl))
{
Console.WriteLine("Warning: Environment variable TFS_URL not set.");
Console.WriteLine(" Some tests cannot be executed without TFS_URL.");
return;
}
string username = Environment.GetEnvironmentVariable("TFS_USERNAME");
if (String.IsNullOrEmpty(username))
{
Console.WriteLine("Warning: No TFS user credentials specified.");
return;
}
credentials = new NetworkCredential(username,
Environment.GetEnvironmentVariable("TFS_PASSWORD"),
Environment.GetEnvironmentVariable("TFS_DOMAIN"));
// need TFS_ envvars for this test
if (String.IsNullOrEmpty(tfsUrl))
{
return;
}
TeamFoundationServer tfs = new TeamFoundationServer(tfsUrl, credentials);
versionControlServer = (VersionControlServer)tfs.GetService(typeof(VersionControlServer));
workspace = versionControlServer.CreateWorkspace("WorkspaceTest",
Environment.GetEnvironmentVariable("TFS_USERNAME"));
}
private T GetService <T>()
{
#region Tracing
#line hidden
if (ChangesetWatcher.m_TraceSwitch.TraceVerbose)
{
Trace.TraceInformation(
"Getting service '{0}' from server '{1}'.",
typeof(T),
Settings.Default.TeamFoundationServerUrl
);
}
#line default
#endregion
TeamFoundationServer server = TeamFoundationServerFactory.GetServer(Settings.Default.TeamFoundationServerUrl);
T service = (T)server.GetService(typeof(T));
#region Tracing
#line hidden
if (ChangesetWatcher.m_TraceSwitch.TraceVerbose)
{
Trace.TraceInformation(
"Service '{0}' successfully retrieved from server '{1}'.",
typeof(T),
Settings.Default.TeamFoundationServerUrl
);
}
#line default
#endregion
return(service);
}
public void Workspace_Get()
{
// need TFS_ envvars for this test
if (String.IsNullOrEmpty(tfsUrl))
{
return;
}
TeamFoundationServer tfs = new TeamFoundationServer(tfsUrl, credentials);
VersionControlServer vcs = (VersionControlServer)tfs.GetService(typeof(VersionControlServer));
WorkingFolder[] folders = new WorkingFolder[1];
string serverItem = String.Format("$/{0}", Environment.GetEnvironmentVariable("TFS_PROJECT"));
folders[0] = new WorkingFolder(serverItem, Environment.CurrentDirectory);
Workspace w1 = vcs.CreateWorkspace("CreateDelete1_Workspace",
Environment.GetEnvironmentVariable("TFS_USERNAME"),
"My Comment", folders, Environment.MachineName);
Workspace w2 = vcs.GetWorkspace("CreateDelete1_Workspace");
Assert.AreEqual("My Comment", w2.Comment);
w1.Delete();
}
public void Workspace_RefreshMappings2()
{
// need TFS_ envvars for this test
if (String.IsNullOrEmpty(tfsUrl))
{
return;
}
TeamFoundationServer tfs = new TeamFoundationServer(tfsUrl, credentials);
VersionControlServer vcs = (VersionControlServer)tfs.GetService(typeof(VersionControlServer));
WorkingFolder[] folders = new WorkingFolder[1];
string serverItem = String.Format("$/{0}", Environment.GetEnvironmentVariable("TFS_PROJECT"));
folders[0] = new WorkingFolder(serverItem, Environment.CurrentDirectory);
Workspace w1 = vcs.CreateWorkspace("CreateDelete1_Workspace",
Environment.GetEnvironmentVariable("TFS_USERNAME"),
"My Comment", folders, Environment.MachineName);
//Workstation.Current.UpdateWorkspaceInfoCache(vcs, Environment.GetEnvironmentVariable("TFS_USERNAME"));
WorkspaceInfo info = Workstation.Current.GetLocalWorkspaceInfo(Environment.CurrentDirectory);
Workspace w2 = info.GetWorkspace(tfs);
// this will talk to the server and get the mapped paths
// BUT it will fail because we don't pass a full path like in RefreshMappings1
w2.RefreshMappings();
string serverItem2 = w2.TryGetServerItemForLocalItem("foo.txt");
Assert.IsNull(serverItem2);
w1.Delete();
}
// This method returns proxy interface by the given namespace and proxy type
internal static object GetProxy(
string teamSystemName, // BIS namespace
Type proxyType) // Type of proxy to return
{
TeamFoundationServer tfs = TeamFoundationServerFactory.GetServer(teamSystemName);
return(tfs.GetService(proxyType));
}
protected override T GetService <T>()
{
if (_server == null)
{
EnsureAuthenticated();
}
return((T)_server.GetService(typeof(T)));
}
private void initializeTfsClient()
{
TeamFoundationServer tfsServer = TeamFoundationServerFactory.GetServer(
ConfigurationService.ServerUrl);
m_tfsClient = (VersionControlServer)tfsServer.GetService(typeof(VersionControlServer));
m_analysisServiceContainer.AddService(typeof(VersionControlServer), m_tfsClient);
}
/// <summary>
/// Perform the adapter-specific initialization
/// </summary>
public virtual void InitializeClient(MigrationSource migrationSource)
{
m_migrationSource = migrationSource;
TeamFoundationServer tfsServer = TeamFoundationServerFactory.GetServer(migrationSource.ServerUrl);
m_tfsClient = (VersionControlServer)tfsServer.GetService(typeof(VersionControlServer));
m_tfsClient.NonFatalError += new ExceptionEventHandler(NonFatalError);
}
private void initializeTfsClient()
{
TeamFoundationServer tfsServer = TeamFoundationServerFactory.GetServer(
m_configurationService.ServerUrl);
m_tfsClient = (VersionControlServer)tfsServer.GetService(typeof(VersionControlServer));
m_tfsClient.NonFatalError += new ExceptionEventHandler(NonFatalError);
}
private void SetWorkItemType()
{
_tfs = new TeamFoundationServer(_settings.TeamServer);
_tfs.EnsureAuthenticated();
_wis = _tfs.GetService(typeof(WorkItemStore)) as WorkItemStore;
SelectedWorkItemType = _wis.Projects[_settings.TeamProject]
.WorkItemTypes[_settings.WorkItemType];
}
/// <summary>
/// Perform the adapter-specific initialization
/// </summary>
public virtual void InitializeClient(MigrationSource migrationSource)
{
TeamFoundationServer tfs = TeamFoundationServerFactory.GetServer(migrationSource.ServerUrl);
tfs.Authenticate();
m_workItemStore = (WorkItemStore)tfs.GetService(typeof(WorkItemStore));
m_projectName = migrationSource.SourceIdentifier;
}
private WorkItemStore GetWorkItemStore(string serverUrl)
{
Trace.TraceInformation("Connecting to '{0}'", serverUrl);
TeamFoundationServer tfs = new TeamFoundationServer(serverUrl);
WorkItemStore wi = (WorkItemStore)tfs.GetService(typeof(WorkItemStore));
Trace.TraceInformation("Connected to '{0}'", serverUrl);
return(wi);
}
public override bool Execute()
{
Server = ""; //TODO: Fill the TFS Server
Root = @"$/DotNetNuke/src/DotNetNuke_CS/";
Committer = ""; //TODO: Fill the committer username.
#pragma warning disable 612,618
TeamFoundationServer tfs = TeamFoundationServerFactory.GetServer(Server);
#pragma warning restore 612,618
var vcs = (VersionControlServer)tfs.GetService(typeof(VersionControlServer));
string path = Root;
VersionSpec version = VersionSpec.Latest;
const int deletionId = 0;
const RecursionType recursion = RecursionType.Full;
string user = null;
VersionSpec versionFrom = null;
VersionSpec versionTo = null;
const int maxCount = 100;
const bool includeChanges = true;
const bool slotMode = true;
const bool includeDownloadInfo = true;
IEnumerable enumerable =
vcs.QueryHistory(path,
version,
deletionId,
recursion,
user,
versionFrom,
versionTo,
maxCount,
includeChanges,
slotMode,
includeDownloadInfo);
var c = new List <Changeset>();
foreach (var i in enumerable)
{
var cs = (i as Changeset);
if (cs != null && cs.Committer != Committer)
{
foreach (var change in cs.Changes)
{
if (!change.Item.ServerItem.Contains("Professional"))
{
c.Add(cs);
}
}
}
}
return(true);
}
/// <summary>
/// Internal helper method to get the service
/// </summary>
/// <typeparam name="T">Type of service to retrieve</typeparam>
/// <param name="credentials">Credentials to use when connecting the service</param>
/// <returns></returns>
private static T GetService <T>(ICredentials credentials)
{
TempCredentials creds = new TempCredentials(credentials);
string teamFoundationServerUrl = Settings.Default.TeamFoundationServerUrl;
TraceHelper.TraceVerbose(Constants.CommonSwitch, "Connecting to server {0} To get service {1} ", teamFoundationServerUrl, typeof(T).ToString());
TeamFoundationServer server = TeamFoundationServerFactory.GetServer(teamFoundationServerUrl, creds);
T service = (T)server.GetService(typeof(T));
return(service);
}
public void ConnectToTfsServer(string hostname, string teamCollection, string projectName, string buildDefinitionName = null)
{
_hostname = hostname;
_isWebServer = _hostname.Contains("://");
try
{
string url;
if (_isWebServer)
{
_hostname = _hostname.TrimEnd('\\', '/');
url = _hostname + "/" + teamCollection;
_urlPrefix = hostname + "/" + teamCollection + "/" + projectName + "/_build#buildUri=";
}
else
{
url = "http://" + _hostname + ":8080/tfs/" + teamCollection;
_urlPrefix = "http://" + hostname + ":8080/tfs/Build/Build.aspx?artifactMoniker=";
}
// Get a connection to the desired Team Foundation Server
_tfServer = TeamFoundationServerFactory.GetServer(url, new UICredentialsProvider());
// Get a reference to a build service
_buildServer = _tfServer.GetService <IBuildServer>();
// Retrieve a list of build definitions
var buildDefs = _buildServer.QueryBuildDefinitions(projectName);
if (buildDefs.Length != 0)
{
if (string.IsNullOrWhiteSpace(buildDefinitionName))
{
_buildDefinition = buildDefs[0];
}
else
{
foreach (var buildDefinition in buildDefs)
{
if (string.Compare(buildDefinition.Name, buildDefinitionName, true) == 0)
{
_buildDefinition = buildDefinition;
return;
}
}
}
}
}
catch (Exception ex)
{
Trace.WriteLine(ex.Message);
}
}
public void GetService_VersionControlServer()
{
// need TFS_ envvars for this test
if (String.IsNullOrEmpty(tfsUrl))
{
return;
}
TeamFoundationServer tfs = new TeamFoundationServer(tfsUrl, credentials);
VersionControlServer vcs = (VersionControlServer)tfs.GetService(typeof(VersionControlServer));
Assert.IsNotNull(vcs);
}
private static WorkItemType GetWorkItemType(string serverName, string teamProjectName, string witName)
{
string serverUrl = string.Format("http://{0}:8080", serverName);
TeamFoundationServer tfsServer = TeamFoundationServerFactory.GetServer(serverUrl);
WorkItemStore wis = (WorkItemStore)tfsServer.GetService(typeof(WorkItemStore));
Project project = wis.Projects[teamProjectName];
Debug.Assert(project != null);
return(project.WorkItemTypes[witName]);
}
private int GetLatestChangeSet(string url, string project)
{
project = string.Format(@"$/{0}", project);
var server = new TeamFoundationServer(new Uri(url));
var version = server.GetService <VersionControlServer>();
var workspace = version.QueryWorkspaces(null, WindowsIdentity.GetCurrent().Name, System.Environment.MachineName).First();
var folder = workspace.Folders.First(f => f.ServerItem == project);
return(workspace.GetLocalVersions(new[] { new ItemSpec(folder.LocalItem, RecursionType.Full) }, false)
.SelectMany(lv => lv.Select(l => l.Version)).Max());
}
static public WorkItemCollection QueryWorkItems(string server, string projectname)
{
TeamFoundationServer tfs = TeamFoundationServerFactory.GetServer(server);
WorkItemStore workItemStore = (WorkItemStore)tfs.GetService(typeof(WorkItemStore));
Project p = workItemStore.Projects[projectname];
string wiqlQuery = "Select * from Issue where [System.TeamProject] = '" + projectname + "'";
wiqlQuery += " and [System.State] <> 'Deleted'";
wiqlQuery += " order by ID";
WorkItemCollection witCollection = workItemStore.Query(wiqlQuery);
return(witCollection);
}
private void PopulateProjects()
{
TeamProjectDropDown.Items.Clear();
TeamFoundationServer tfs = TeamFoundationServerFactory.GetServer(lblServerUri.Text);
ICommonStructureService projectCollection =
(ICommonStructureService)tfs.GetService(typeof(ICommonStructureService));
foreach (ProjectInfo projectInfo in projectCollection.ListProjects())
{
TeamProjectDropDown.Items.Add(projectInfo.Name);
}
TeamProjectDropDown.Enabled = true;
}
private void BuildStoreWorker_DoWork(object sender, DoWorkEventArgs e)
{
TeamFoundationServer server = new TeamFoundationServer(_teamFoundationServerUri, CredentialCache.DefaultCredentials);
server.EnsureAuthenticated();
while (!this.CancellationPending)
{
BuildStore store = (BuildStore)server.GetService(typeof(BuildStore));
BuildData[] builds = store.GetListOfBuilds(_teamProjectName, _teamBuildTypeName);
this.ReportProgress(0, builds);
Thread.Sleep(30000);
}
}