static void Main(string[] args)
{
const String c_collectionUri = "https://dev.azure.com/microsoft";
const String c_projectName = "Edge";
const String c_repoName = "chromium.src";
// Interactively ask the user for credentials, caching them so the user isn't constantly prompted
VssCredentials creds = new VssClientCredentials();
creds.Storage = new VssClientCredentialStorage();
// Connect to Azure DevOps Services
VssConnection connection = new VssConnection(new Uri(c_collectionUri), creds);
// Get a GitHttpClient to talk to the Git endpoints
GitHttpClient gitClient = connection.GetClient <GitHttpClient>();
// Get data about a specific repository
var repo = gitClient.GetRepositoryAsync(c_projectName, c_repoName).Result;
// Create instance of WorkItemTrackingHttpClient using VssConnection
WorkItemTrackingHttpClient witClient = connection.GetClient <WorkItemTrackingHttpClient>();
// Get 2 levels of query hierarchy items
List <QueryHierarchyItem> queryHierarchyItems = witClient.GetQueriesAsync(c_projectName, depth: 2).Result;
// Search for 'My Queries' folder
QueryHierarchyItem myQueriesFolder = queryHierarchyItems.FirstOrDefault(qhi => qhi.Name.Equals("My Queries"));
if (myQueriesFolder != null)
{
var foo = "Skippy";
}
}
public override VssCredentials GetVssCredentials(IHostContext context)
{
ArgUtil.NotNull(context, nameof(context));
Tracing trace = context.GetTrace(nameof(AlternateCredential));
trace.Info(nameof(GetVssCredentials));
string username;
if (!CredentialData.Data.TryGetValue(Constants.Agent.CommandLine.Args.UserName, out username))
{
username = null;
}
string password;
if (!CredentialData.Data.TryGetValue(Constants.Agent.CommandLine.Args.Password, out password))
{
password = null;
}
ArgUtil.NotNull(username, nameof(username));
ArgUtil.NotNull(password, nameof(password));
trace.Info("username retrieved: {0} chars", username.Length);
trace.Info("password retrieved: {0} chars", password.Length);
VssBasicCredential loginCred = new VssBasicCredential(username, password);
VssCredentials creds = new VssClientCredentials(loginCred);
trace.Verbose("cred created");
return(creds);
}
static void Main(string[] args)
{
Uri serverUrl = new Uri(vstsUrl);
VssCredentials credentials = new VssClientCredentials();
credentials.Storage = new VssClientCredentialStorage();
VssConnection connection = new VssConnection(serverUrl, credentials);
WorkItemTrackingHttpClient workItemTrackingClient = connection.GetClient <WorkItemTrackingHttpClient>();
JsonPatchDocument patchDocument = new JsonPatchDocument();
patchDocument.Add(
new JsonPatchOperation()
{
Operation = Operation.Add,
Path = "/fields/System.Tags",
Value = "tag1"
}
);
patchDocument.Add(
new JsonPatchOperation()
{
Operation = Operation.Add,
Path = "/fields/System.Title",
Value = "Sample task with tags"
}
);
var newWorkItem = workItemTrackingClient.CreateWorkItemAsync(patchDocument, "MyAgile2", "Task").Result;
}
public bool Authenticate(string url, string userId, string password, string domain)
{
try
{
NetworkCredential credential = new NetworkCredential(userId, password, domain);
WindowsCredential winCred = new WindowsCredential(credential);
VssCredentials vssCred = new VssClientCredentials(winCred)
{
PromptType = CredentialPromptType.DoNotPrompt
};
using (TfsTeamProjectCollection tpc = new TfsTeamProjectCollection(new Uri(url), vssCred))
{
tpc.EnsureAuthenticated();
return(true);
}
}
catch (TeamFoundationServiceUnavailableException ex)
{
logger.Error(ex, "Service not available");
throw new ServiceUnavailableException(url, "Service not Available", ex);
}
catch (TeamFoundationServerUnauthorizedException ex)
{
logger.Error(ex, "Authentication Failure.");
throw new TFSAuthenticationException("Authentication Failure.", ex);
}
catch (Exception ex)
{
logger.Error(ex, "Authentication Failure.");
throw;
}
}
static void Main(string[] args)
{
var myCredentials = new VssClientCredentials();
var connection = new VssConnection(new Uri(@"http://server:8080/tfs/DefaultCollection"), myCredentials);
WorkItemTrackingHttpClient workItemTrackingClient = connection.GetClient <WorkItemTrackingHttpClient>();
int workitemid = 112;
JsonPatchDocument patchDocument = new JsonPatchDocument();
patchDocument.Add(
new JsonPatchOperation()
{
Operation = Operation.Test,
Path = "/rev",
Value = "6"
}
);
patchDocument.Add(
new JsonPatchOperation()
{
Operation = Operation.Add,
Path = "/fields/System.AssignedTo",
Value = "Domain\\user"
}
);
Microsoft.TeamFoundation.WorkItemTracking.WebApi.Models.WorkItem result = workItemTrackingClient.UpdateWorkItemAsync(patchDocument, workitemid).Result;
}
public override VssCredentials GetVssCredentials(IHostContext context)
{
Tracing trace = context.GetTrace("PersonalAccessToken");
trace.Info("GetVssCredentials()");
if (CredentialData == null || !CredentialData.Data.ContainsKey("token"))
{
throw new InvalidOperationException("Must call ReadCredential first.");
}
string username = CredentialData.Data["Username"];
trace.Info("username retrieved: {0} chars", username.Length);
string password = CredentialData.Data["Password"];
trace.Info("password retrieved: {0} chars", password.Length);
// PAT uses a basic credential
VssBasicCredential loginCred = new VssBasicCredential(username, password);
VssCredentials creds = new VssClientCredentials(loginCred);
trace.Verbose("cred created");
return(creds);
}
static void Main(string[] args)
{
var vssClientCredentials = new VssClientCredentials();
vssClientCredentials.Storage = new VssClientCredentialStorage();
VssConnection connection = new VssConnection(new Uri("https://reeferwatch.visualstudio.com"), vssClientCredentials);
connection.ConnectAsync().Wait();
var projectHttpClient = connection.GetClient <ProjectHttpClient>();
var projects = projectHttpClient.GetProjects().Result;
var project = projects.First();
var buildHttpClient = connection.GetClient <BuildHttpClient>();
var buildDefinitions = buildHttpClient.GetDefinitionsAsync(project.Id).Result;
System.Console.WriteLine($"{buildDefinitions.Count} builds in {project.Name}");
foreach (var definitionReference in buildDefinitions)
{
var builds = buildHttpClient.GetBuildsAsync(project.Id, new[] { definitionReference.Id }).Result;
System.Console.WriteLine($"{definitionReference.Name}: {string.Join(",", builds.Take(5).Select(x => x.Result.ToString()))}");
}
System.Console.ReadLine();
}
static void Main(string[] args)
{
Console.WriteLine("Server URL");
serverUrl = Console.ReadLine();
Console.WriteLine("Collection URL");
collectionUrl = Console.ReadLine();
Console.WriteLine("Type 1 to list permissions, Type 2 to list and remove permissions");
string option = Console.ReadLine();
VssCredentials creds = new VssClientCredentials();
creds.Storage = new VssClientCredentialStorage();
connection = new VssConnection(new Uri(collectionUrl), creds);
if (option.Equals("1"))
{
ListGitNamespacePermissions();
}
else if (option.Equals("2"))
{
ListAndRemoveGitNamespacePermissions();
}
}
public static async Task <VssConnection> GetVssConnectionAsync(Uri uri, string accessToken, DelegatingHandler retryOnTimeoutMessageHandler = null)
{
VssConnection connection;
if (!_vssConnections.TryGetValue(uri, out connection))
{
VssClientCredentials cred = GetCredentials(accessToken);
DelegatingHandler[] handlers = new DelegatingHandler[]
{
retryOnTimeoutMessageHandler
};
connection = ApiUtil.CreateConnection(uri, cred, handlers);
connection.Settings.SendTimeout = TimeSpan.FromSeconds(Math.Max(_minTimeout.TotalSeconds, connection.Settings.SendTimeout.TotalSeconds));
await connection.ConnectAsync().ConfigureAwait(false);
if (!_vssConnections.TryAdd(uri, connection))
{
// first writer wins. Every caller returned the same instance.
connection = _vssConnections[uri];
}
}
return(connection);
}
public async static void UpdateAllBuildDefinitionRetention()
{
var tpc = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(collectionUrl));
var bhc = tpc.GetClient <BuildHttpClient>();
VssCredentials creds = new VssClientCredentials();
creds.Storage = new VssClientCredentialStorage();
connection = new VssConnection(new Uri(collectionUrl), creds);
ProjectHttpClient projectClient = connection.GetClient <ProjectHttpClient>();
List <BuildDefinitionReference> buildDefinitions = new List <BuildDefinitionReference>();
// Call to get the list of projects
IEnumerable <TeamProjectReference> projects = projectClient.GetProjects(top: 1000).Result;
foreach (var project in projects)
{
// Iterate (as needed) to get the full set of build definitions
string continuationToken = null;
do
{
IPagedList <BuildDefinitionReference> buildDefinitionsPage = bhc.GetDefinitionsAsync2(
project: project.Name,
continuationToken: continuationToken).Result;
buildDefinitions.AddRange(buildDefinitionsPage);
continuationToken = buildDefinitionsPage.ContinuationToken;
} while (!String.IsNullOrEmpty(continuationToken));
}
try
{
foreach (BuildDefinitionReference definition in buildDefinitions)
{
string teamProject = definition.Project.Name;
string definitionName = definition.Name;
int definitionId = definition.Id;
try
{
BuildDefinition buildDefTemplate = (await bhc.GetDefinitionAsync(teamProject, definitionId));
buildDefTemplate.RetentionRules[0].ArtifactsToDelete.Clear();
await bhc.UpdateDefinitionAsync(buildDefTemplate, teamProject);
Console.WriteLine("Completed - " + "Project Name: " + teamProject + " - Build Definition Name: " + definitionName);
}
catch (Exception ex)
{
Console.WriteLine("Error - " + "Project Name: " + teamProject + " - Build Definition Name: " + definitionName + "Error Msg: " + ex.Message);
}
}
Console.Write("UPDATE COMPLETED");
}
catch (Exception ex)
{
string exception = ex.ToString();
}
}
public static void LookupBranchesOnline() //Dictionary<string, string>
{
Uri tfsUri = new Uri(AppUtils.GetAppSetting <string>("TFPath"));
//var vssCredentials = new VssCredentials("", );
NetworkCredential netCred = new NetworkCredential(@"DOMAIN\user.name", @"Password1");
var winCred = new Microsoft.VisualStudio.Services.Common.WindowsCredential(netCred);
VssCredentials vssCred = new VssClientCredentials(winCred);
// Bonus - if you want to remain in control when
// credentials are wrong, set 'CredentialPromptType.DoNotPrompt'.
// This will thrown exception 'TFS30063' (without hanging!).
// Then you can handle accordingly.
vssCred.PromptType = CredentialPromptType.DoNotPrompt;
// Now you can connect to TFS passing Uri and VssCredentials instances as parameters
var tfsTeamProjectCollection = new TfsTeamProjectCollection(tfsUri, vssCred);
// Finally, to make sure you are authenticated...
tfsTeamProjectCollection.EnsureAuthenticated();
var tfs = new TfsTeamProjectCollection(tfsUri);
var identity = tfs.AuthorizedIdentity;
tfs.Authenticate();
var versionControlServer = tfs.GetService <VersionControlServer>();
var workspaces = versionControlServer.QueryWorkspaces(null, null, null, WorkspacePermissions.NoneOrNotSupported);
foreach (var ws in workspaces)
{
string comment = ws.Comment;
}
}
public async Task <IDictionary <string, string> > GetReleaseEnvironmentVariables(
string projectId,
string releaseDefinitionName,
string environmentName)
{
if (string.IsNullOrWhiteSpace(projectId))
{
throw new ArgumentNullException(nameof(projectId));
}
if (string.IsNullOrWhiteSpace(releaseDefinitionName))
{
throw new ArgumentNullException(nameof(releaseDefinitionName));
}
if (string.IsNullOrWhiteSpace(environmentName))
{
throw new ArgumentNullException(nameof(environmentName));
}
var credentials = new VssClientCredentials
{
Storage = new VssClientCredentialStorage()
};
var connection = new VssConnection(this.tfsUri, credentials);
var client = connection.GetClient <ReleaseHttpClient>();
var releaseDefinitions = await client.GetReleaseDefinitionsAsync(
projectId,
searchText : null,
expand : ReleaseDefinitionExpands.Environments | ReleaseDefinitionExpands.Variables);
var releaseDefinition = releaseDefinitions.FirstOrDefault(r => r.Name == releaseDefinitionName);
if (releaseDefinition == null)
{
throw new InvalidOperationException(
$"Release definition '{releaseDefinitionName}' not found in project '{projectId}'");
}
var environment = releaseDefinition.Environments.FirstOrDefault(e => e.Name == environmentName);
if (environment == null)
{
throw new InvalidOperationException(
$"Release environment '{environmentName}' not found in release '{releaseDefinitionName}' in project '{projectId}'");
}
var releaseVariables = releaseDefinition.Variables.ToDictionary(
kvp => kvp.Key,
kvp => kvp.Value.Value);
var environmentVariables = environment.Variables.ToDictionary(
kvp => kvp.Key,
kvp => kvp.Value.Value);
return(releaseVariables.MergeLeft(environmentVariables));
}
public virtual async Task SetUp()
{
var collectionUrl = Environment.GetEnvironmentVariable("WILINQ_TEST_TPCURL");
if (string.IsNullOrWhiteSpace(collectionUrl))
{
throw new InvalidOperationException("Environment variable 'WILINQ_TEST_TPCURL' is missing");
}
var personnalAccessToken = Environment.GetEnvironmentVariable("WILINQ_TEST_PAT");
VssCredentials vssCredentials;
if (string.IsNullOrWhiteSpace(personnalAccessToken))
{
vssCredentials = new VssClientCredentials
{
Storage = new VssClientCredentialStorage()
};
}
else
{
vssCredentials = new VssBasicCredential(string.Empty, personnalAccessToken);
}
var connection = new VssConnection(new Uri(collectionUrl), vssCredentials);
await connection.ConnectAsync();
Client = await connection.GetClientAsync <WorkItemTrackingHttpClient>();
var projectHttpClient = await connection.GetClientAsync <ProjectHttpClient>();
Project = await projectHttpClient.GetProject("WiLinqTestProject");
TestSessionId = Guid.NewGuid().ToString();
}
public static async Task <VssConnection> GetVssConnectionAsync(Uri uri, string accessToken, DelegatingHandler retryOnTimeoutMessageHandler = null)
{
VssConnection connection;
if (!_vssConnections.TryGetValue(uri, out connection))
{
VssClientCredentials cred = GetCredentials(accessToken);
VssClientHttpRequestSettings settings = VssClientHttpRequestSettings.Default.Clone();
if (settings.SendTimeout < _minTimeout)
{
settings.SendTimeout = _minTimeout;
}
VssHttpMessageHandler innerHandler = new VssHttpMessageHandler(cred, settings);
DelegatingHandler[] handlers = new DelegatingHandler[]
{
retryOnTimeoutMessageHandler
};
connection = new VssConnection(uri, innerHandler, handlers);
await connection.ConnectAsync().ConfigureAwait(false);
if (!_vssConnections.TryAdd(uri, connection))
{
// first writer wins. Every caller returned the same instance.
connection = _vssConnections[uri];
}
}
return(connection);
}
public WorkItemHandler()
{
XmlDocument doc = new XmlDocument();
doc.Load("AzureDevops.xml");
string azureDevOpsUrl = doc.DocumentElement.SelectSingleNode("/Data/Connection/Url").InnerText;
project = doc.DocumentElement.SelectSingleNode("/Data/Connection/Project").InnerText;
areaPath = doc.DocumentElement.SelectSingleNode("/Data/TestCase/AreaPath").InnerText;
customFields = new List <KeyValuePair <string, string> >();
XmlNodeList fieldList = doc.DocumentElement.SelectNodes("/Data/TestCase/CustomFields/CustomField");
foreach (XmlNode field in fieldList)
{
customFields.Add(field.Attributes["id"].Value, field.Attributes["defaultvalue"].Value);
}
setup = new Setup();
if (setup.IsTestAgentRun)
{
string accessToken = Environment.GetEnvironmentVariable("SYSTEM_ACCESSTOKEN");
Assert.IsTrue(!string.IsNullOrEmpty(accessToken), "Cannot retrieve access token in pipeline");
VssBasicCredential credentials = new VssBasicCredential("", accessToken);
connection = new VssConnection(new Uri(azureDevOpsUrl), credentials);
}
else
{
VssClientCredentials credentials = new VssClientCredentials();
connection = new VssConnection(new Uri(azureDevOpsUrl), credentials);
}
witClient = connection.GetClient <WorkItemTrackingHttpClient>();
}
public VstsClient(Uri projectUrl, string pat, VstsSettings settings)
{
if (projectUrl == null)
{
throw new ArgumentNullException("projectUrl");
}
if (projectUrl.LocalPath == "/")
{
throw new ArgumentException("Invalid URL: The URL must have the format: 'https://<account>.visualstudio.com/<project>'.", "projectUrl");
}
var urlWrapper = new UrlWrapper(projectUrl);
_projectName = urlWrapper.ProjectName;
var baseUrl = urlWrapper.ProjectCollectionUri;
_settings = settings;
VssCredentials credentials = string.IsNullOrEmpty(pat)
? credentials = new VssClientCredentials()
: new VssBasicCredential(string.Empty, pat);
var connection = new VssConnection(baseUrl, credentials);
_client = connection.GetClient <WorkItemTrackingHttpClient>();
}
public override VssCredentials GetVssCredentials(IHostContext context)
{
ArgUtil.NotNull(context, nameof(context));
Tracing trace = context.GetTrace(nameof(PersonalAccessToken));
trace.Info(nameof(GetVssCredentials));
ArgUtil.NotNull(CredentialData, nameof(CredentialData));
string token;
if (!CredentialData.Data.TryGetValue(Constants.Agent.CommandLine.Args.Token, out token))
{
token = null;
}
ArgUtil.NotNullOrEmpty(token, nameof(token));
trace.Info("token retrieved: {0} chars", token.Length);
// PAT uses a basic credential
VssBasicCredential basicCred = new VssBasicCredential("VstsAgent", token);
VssCredentials creds = new VssClientCredentials(basicCred);
trace.Verbose("cred created");
return(creds);
}
public static void GetAllTeamProjects_Library()
{
// Interactively ask the user for credentials, caching them so the user isn't constantly prompted
VssCredentials creds = new VssClientCredentials();
creds.Storage = new VssClientCredentialStorage();
// Connect to Azure DevOps Services
connection = new VssConnection(new Uri(collectionUrl), creds);
ProjectHttpClient projectClient = connection.GetClient <ProjectHttpClient>();
IEnumerable <TeamProjectReference> projects = projectClient.GetProjects(top: 1000).Result;
foreach (var project in projects)
{
try
{
string projectName = project.Name.ToString();
}
catch (Exception ex)
{
}
}
}
public HttpClient BuildHttpClient()
{
VssCredentials credentials = new VssClientCredentials();
credentials.Storage = new VssClientCredentialStorage("VssApp", "VisualStudio");
HttpClient toReturn = new HttpClient(new VssHttpMessageHandler(credentials, new VssHttpRequestSettings()));
toReturn.Timeout = TimeSpan.FromSeconds(30);
toReturn.DefaultRequestHeaders.Add("User-Agent", userAgent);
return toReturn;
}
protected override TfsTeamProjectCollection GetTfsCredential(Uri uri)
{
var winCred = HasCredentials ?
new Microsoft.VisualStudio.Services.Common.WindowsCredential(GetCredential()) :
new Microsoft.VisualStudio.Services.Common.WindowsCredential(true);
var vssCred = new VssClientCredentials(winCred);
return(new TfsTeamProjectCollection(uri, vssCred));
}
public AzureDevOpsAgent()
{
// Interactively ask the user for credentials, caching them so the user isn't constantly prompted
VssCredentials creds = new VssClientCredentials();
creds.Storage = new VssClientCredentialStorage();
// Connect to Azure DevOps Services
connection = new VssConnection(new Uri(c_collectionUri), creds);
}
private static void Authenticate(TFSCredentials credentials)
{
NetworkCredential netCred = new NetworkCredential(credentials.username, credentials.password);
Microsoft.VisualStudio.Services.Common.WindowsCredential winCred = new Microsoft.VisualStudio.Services.Common.WindowsCredential(netCred);
VssCredentials vssCred = new VssClientCredentials(winCred);
_tfs = new TfsTeamProjectCollection(new Uri("https://tfs.aurigo.com/tfs/DefaultCollection"), vssCred);
_tfs.Authenticate();
}
protected override TfsTeamProjectCollection GetTfsCredential(Uri uri)
{
var vssCred = HasCredentials
? new VssClientCredentials(new WindowsCredential(GetCredential()))
: VssClientCredentials.LoadCachedCredentials(uri, false, CredentialPromptType.PromptIfNeeded);
return(new TfsTeamProjectCollection(uri, vssCred));
#pragma warning restore 618
}
public WorkItemRevisionReplayMigrationContext(MigrationEngine me, WorkItemRevisionReplayMigrationConfig config)
: base(me, config)
{
_config = config;
PopulateIgnoreList();
VssClientCredentials adoCreds = new VssClientCredentials();
witClient = new WorkItemTrackingHttpClient(me.Target.Collection.Uri, adoCreds);
}
public override VssCredentials GetVssCredentials(IHostContext context)
{
ArgUtil.NotNull(context, nameof(context));
Tracing trace = context.GetTrace(nameof(NegotiateCredential));
trace.Info(nameof(GetVssCredentials));
ArgUtil.NotNull(CredentialData, nameof(CredentialData));
// Get the user name from the credential data.
string userName;
if (!CredentialData.Data.TryGetValue(Constants.Agent.CommandLine.Args.UserName, out userName))
{
userName = null;
}
ArgUtil.NotNullOrEmpty(userName, nameof(userName));
trace.Info("User name retrieved.");
// Get the password from the credential data.
string password;
if (!CredentialData.Data.TryGetValue(Constants.Agent.CommandLine.Args.Password, out password))
{
password = null;
}
ArgUtil.NotNullOrEmpty(password, nameof(password));
trace.Info("Password retrieved.");
// Get the URL from the credential data.
string url;
if (!CredentialData.Data.TryGetValue(Constants.Agent.CommandLine.Args.Url, out url))
{
url = null;
}
ArgUtil.NotNullOrEmpty(url, nameof(url));
trace.Info($"URL retrieved: {url}");
// Create the Negotiate and NTLM credential object.
var credential = new NetworkCredential(userName, password);
var credentialCache = new CredentialCache();
switch (Constants.Agent.Platform)
{
case Constants.OSPlatform.Linux:
case Constants.OSPlatform.OSX:
credentialCache.Add(new Uri(url), "NTLM", credential);
break;
case Constants.OSPlatform.Windows:
credentialCache.Add(new Uri(url), "Negotiate", credential);
break;
}
VssCredentials creds = new VssClientCredentials(new WindowsCredential(credentialCache));
trace.Verbose("cred created");
return creds;
}
public override VssCredentials GetVssCredentials(IHostContext context)
{
Tracing trace = context.GetTrace("PersonalAccessToken");
trace.Info("GetVssCredentials()");
VssBasicCredential loginCred = new VssBasicCredential("test", "password");
VssCredentials creds = new VssClientCredentials(loginCred);
trace.Verbose("cred created");
return creds;
}
public AzureDevOpsService(string organizationUrl, string username, string token, Guid projectId)
{
VssClientCredentials clientCredentials =
new VssClientCredentials(new VssBasicCredential(username, token));
OrganizationUrl = organizationUrl ?? throw new ArgumentNullException(nameof(organizationUrl));
Username = username ?? throw new ArgumentNullException(nameof(username));
Token = token ?? throw new ArgumentNullException(nameof(token));
ProjectId = projectId;
Connection = new VssConnection(new Uri(OrganizationUrl), clientCredentials);
}
public AzureDevOpsClient(string organizationName)
{
organizationName = organizationName.Trim();
Endpoint = new Uri(@"https://dev.azure.com/" + organizationName + "/");
var creds = new VssClientCredentials(new WindowsCredential(false), new VssFederatedCredential(true), CredentialPromptType.PromptIfNeeded);
azureDevopsConnection = new VssConnection(Endpoint, creds);
azureDevopsConnection.ConnectAsync().Wait();
buildClient = azureDevopsConnection.GetClient <BuildHttpClient>();
projectClient = azureDevopsConnection.GetClient <ProjectHttpClient>();
}
private static void CreateAuthConnection(string VssAccountUrl)
{
// Create a connection to the specified account.
// If you change the false to true, your credentials will be saved.
var creds = new VssClientCredentials(true);
vssConnection = new VssConnection(new Uri(VssAccountUrl), creds);
// We need the clients for two services: Licensing and Identity
licensingClient = vssConnection.GetClient <LicensingHttpClient>();
identityClient = vssConnection.GetClient <IdentityHttpClient>();
}
public AzureDevOpsClientContext(Uri url, VssCredentials credentials)
{
Url = url;
if (credentials == null)
{
Credentials = new VssClientCredentials();
}
else
{
Credentials = credentials;
}
}
public void Connect(string serverName)
{
// Interactively ask the user for credentials, caching them so the user isn't constantly prompted
VssCredentials creds = new VssClientCredentials();
creds.Storage = new VssClientCredentialStorage();
// Connect to Azure DevOps Services
_connection = new VssConnection(new Uri(serverName), creds);
_connection.ConnectAsync().SyncResult();
Debug.WriteLine("Has authenticaed: " + _connection.HasAuthenticated);
}
public override VssCredentials GetVssCredentials(IHostContext context)
{
Tracing trace = context.GetTrace("PersonalAccessToken");
trace.Info("GetVssCredentials()");
VssBasicCredential loginCred = new VssBasicCredential("test", "password");
VssCredentials creds = new VssClientCredentials(loginCred);
trace.Verbose("cred created");
return(creds);
}
/// <summary>
/// Connects to the AzureDevOps server at the given url (e.g. https://myaccount.visualstudio.com)
/// If prompt is true, then we may prompt if needed - otherwise, we turn prompting off on credentials
/// </summary>
/// <param name="url">AzureDevOps URL to connect to</param>
/// <param name="prompt">whether user should see any login prompts if needed</param>
/// <returns></returns>
internal Task ConnectToAzureDevOpsAccount(Uri url, CredentialPromptType prompt = CredentialPromptType.PromptIfNeeded)
{
lock (myLock)
{
// reset connection state
Disconnect();
var credentials = new VssClientCredentials(false);
credentials.Storage = new VssClientCredentialStorage();
credentials.PromptType = prompt;
_baseServerConnection = new VssConnection(url, credentials);
return(_baseServerConnection.ConnectAsync());
}
}
public override VssCredentials GetVssCredentials(IHostContext context)
{
ArgUtil.NotNull(context, nameof(context));
Tracing trace = context.GetTrace(nameof(PersonalAccessToken));
trace.Info(nameof(GetVssCredentials));
ArgUtil.NotNull(CredentialData, nameof(CredentialData));
string token;
if (!CredentialData.Data.TryGetValue(Constants.Agent.CommandLine.Args.Token, out token))
{
token = null;
}
ArgUtil.NotNullOrEmpty(token, nameof(token));
trace.Info("token retrieved: {0} chars", token.Length);
// PAT uses a basic credential
VssBasicCredential basicCred = new VssBasicCredential("VstsAgent", token);
VssCredentials creds = new VssClientCredentials(basicCred);
trace.Verbose("cred created");
return creds;
}
