public bool LoginWithToken(UriString host, string token)
{
Guard.ArgumentNotNull(host, nameof(host));
Guard.ArgumentNotNullOrWhiteSpace(token, nameof(token));
var keychainAdapter = keychain.Connect(host);
keychainAdapter.Set(new Credential(host, "[token]", token));
try
{
var username = RetrieveUsername(token, host);
keychainAdapter.Update(token, username);
keychain.SaveToSystem(host);
return(true);
}
catch (Exception e)
{
logger.Warning(e, "Login Exception");
keychain.Clear(host, false);
return(false);
}
}
private async Task <GitHubRepository> CreateRepositoryInternal(string repositoryName, string organization, string description, bool isPrivate)
{
try
{
logger.Trace("Creating repository");
var user = await GetCurrentUser();
var keychainAdapter = keychain.Connect(OriginalUrl);
var command = new StringBuilder("publish -r \"");
command.Append(repositoryName);
command.Append("\"");
if (!string.IsNullOrEmpty(description))
{
command.Append(" -d \"");
command.Append(description);
command.Append("\"");
}
if (!string.IsNullOrEmpty(organization))
{
command.Append(" -o \"");
command.Append(organization);
command.Append("\"");
}
if (isPrivate)
{
command.Append(" -p");
}
var octorunTask = new OctorunTask(taskManager.Token, nodeJsExecutablePath, octorunScriptPath, command.ToString(),
user: user.Login, userToken: keychainAdapter.Credential.Token)
.Configure(processManager);
var ret = await octorunTask.StartAwait();
if (ret.IsSuccess && ret.Output.Length == 2)
{
return(new GitHubRepository
{
Name = ret.Output[0],
CloneUrl = ret.Output[1]
});
}
throw new ApiClientException(ret.GetApiErrorMessage() ?? "Publish failed");
}
catch (Exception ex)
{
logger.Error(ex, "Error Creating Repository");
throw;
}
}
/// <inheritdoc/>
public async Task <LoginResultData> Login(
UriString host,
string username,
string password)
{
Guard.ArgumentNotNull(host, nameof(host));
Guard.ArgumentNotNullOrWhiteSpace(username, nameof(username));
Guard.ArgumentNotNullOrWhiteSpace(password, nameof(password));
// Start by saving the username and password, these will be used by the `IGitHubClient`
// until an authorization token has been created and acquired:
keychain.Connect(host);
keychain.SetCredentials(new Credential(host, username, password));
try
{
var loginResultData = await TryLogin(host, username, password);
if (loginResultData.Code == LoginResultCodes.Success || loginResultData.Code == LoginResultCodes.CodeRequired)
{
if (string.IsNullOrEmpty(loginResultData.Token))
{
throw new InvalidOperationException("Returned token is null or empty");
}
if (loginResultData.Code == LoginResultCodes.Success)
{
username = await RetrieveUsername(loginResultData, username);
}
keychain.SetToken(host, loginResultData.Token, username);
if (loginResultData.Code == LoginResultCodes.Success)
{
await keychain.Save(host);
}
return(loginResultData);
}
return(loginResultData);
}
catch (Exception e)
{
logger.Warning(e, "Login Exception");
await keychain.Clear(host, false);
return(new LoginResultData(LoginResultCodes.Failed, Localization.LoginFailed, host));
}
}
public OctorunTask(CancellationToken token, IKeychain keychain, IEnvironment environment,
string arguments,
IOutputProcessor <OctorunResult> processor = null)
: base(token, processor ?? new OctorunResultOutputProcessor())
{
this.clientId = ApplicationInfo.ClientId;
this.clientSecret = ApplicationInfo.ClientSecret;
this.pathToNodeJs = environment.NodeJsExecutablePath;
this.pathToOctorunJs = environment.OctorunScriptPath;
this.arguments = $"\"{pathToOctorunJs}\" {arguments}";
var cloneUrl = environment.Repository?.CloneUrl;
var host = String.IsNullOrEmpty(cloneUrl)
? UriString.ToUriString(HostAddress.GitHubDotComHostAddress.WebUri)
: new UriString(cloneUrl.ToRepositoryUri()
.GetComponents(UriComponents.SchemeAndServer, UriFormat.SafeUnescaped));
var adapter = keychain.Connect(host);
if (adapter.Credential?.Token != null)
{
userToken = adapter.Credential.Token;
}
else
{
// use a cached adapter if there is one filled out
adapter = keychain.LoadFromSystem(host);
if (adapter != null)
{
userToken = adapter.Credential.Token;
}
}
}
public static IApiClient Create(UriString repositoryUrl, IKeychain keychain)
{
var credentialStore = keychain.Connect(repositoryUrl);
var hostAddress = HostAddress.Create(repositoryUrl);
return(new ApiClient(repositoryUrl, keychain,
new GitHubClient(AppConfiguration.ProductHeader, credentialStore, hostAddress.ApiUri)));
}
public static IApiClient Create(UriString repositoryUrl, IKeychain keychain, IProcessManager processManager, ITaskManager taskManager, NPath nodeJsExecutablePath, NPath octorunScriptPath)
{
logger.Trace("Creating ApiClient: {0}", repositoryUrl);
var credentialStore = keychain.Connect(repositoryUrl);
var hostAddress = HostAddress.Create(repositoryUrl);
return(new ApiClient(repositoryUrl, keychain,
processManager, taskManager, nodeJsExecutablePath, octorunScriptPath));
}
public async Task <bool> ValidateCredentials()
{
try
{
var store = keychain.Connect(OriginalUrl);
if (store.OctokitCredentials != Credentials.Anonymous)
{
var credential = store.Credential;
await githubClient.Authorization.CheckApplicationAuthentication(ApplicationInfo.ClientId, credential.Token);
}
}
catch
{
return(false);
}
return(true);
}
public void CreateRepository(string name, string description, bool isPrivate, Action <GitHubRepository, Exception> callback, string organization = null)
{
Guard.ArgumentNotNull(callback, "callback");
new FuncTask <GitHubRepository>(taskManager.Token, () =>
{
var user = GetCurrentUser();
var keychainAdapter = keychain.Connect(OriginalUrl);
var command = new StringBuilder("publish -r \"");
command.Append(name);
command.Append("\"");
if (!string.IsNullOrEmpty(description))
{
command.Append(" -d \"");
command.Append(description);
command.Append("\"");
}
if (!string.IsNullOrEmpty(organization))
{
command.Append(" -o \"");
command.Append(organization);
command.Append("\"");
}
if (isPrivate)
{
command.Append(" -p");
}
var octorunTask = new OctorunTask(taskManager.Token, nodeJsExecutablePath, octorunScriptPath, command.ToString(),
user: user.Login, userToken: keychainAdapter.Credential.Token)
.Configure(processManager);
var ret = octorunTask.RunSynchronously();
if (ret.IsSuccess && ret.Output.Length == 2)
{
return(new GitHubRepository
{
Name = ret.Output[0],
CloneUrl = ret.Output[1]
});
}
throw new ApiClientException(ret.GetApiErrorMessage() ?? "Publish failed");
})
.FinallyInUI((success, ex, repository) =>
{
if (success)
{
callback(repository, null);
}
else
{
logger.Error(ex, "Error creating repository");
callback(null, ex);
}
})
.Start();
}
/// <inheritdoc/>
public async Task <LoginResultData> Login(
UriString host,
IGitHubClient client,
string username,
string password)
{
Guard.ArgumentNotNull(host, nameof(host));
Guard.ArgumentNotNull(client, nameof(client));
Guard.ArgumentNotNullOrWhiteSpace(username, nameof(username));
Guard.ArgumentNotNullOrWhiteSpace(password, nameof(password));
// Start by saving the username and password, these will be used by the `IGitHubClient`
// until an authorization token has been created and acquired:
keychain.Connect(host);
keychain.SetCredentials(new Credential(host, username, password));
var newAuth = new NewAuthorization
{
Scopes = scopes,
Note = authorizationNote,
Fingerprint = fingerprint,
};
ApplicationAuthorization auth = null;
try
{
logger.Info("Login Username:{0}", username);
auth = await CreateAndDeleteExistingApplicationAuthorization(client, newAuth, null);
EnsureNonNullAuthorization(auth);
}
catch (TwoFactorAuthorizationException e)
{
LoginResultCodes result;
if (e is TwoFactorRequiredException)
{
result = LoginResultCodes.CodeRequired;
logger.Debug("2FA TwoFactorAuthorizationException: {0} {1}", LoginResultCodes.CodeRequired, e.Message);
}
else
{
result = LoginResultCodes.CodeFailed;
logger.Error(e, "2FA TwoFactorAuthorizationException: {0} {1}", LoginResultCodes.CodeRequired, e.Message);
}
return(new LoginResultData(result, e.Message, client, host, newAuth));
}
catch (LoginAttemptsExceededException e)
{
logger.Warning(e, "Login LoginAttemptsExceededException: {0}", e.Message);
await keychain.Clear(host, false);
return(new LoginResultData(LoginResultCodes.LockedOut, Localization.LockedOut, host));
}
catch (ApiValidationException e)
{
logger.Warning(e, "Login ApiValidationException: {0}", e.Message);
var message = e.ApiError.FirstErrorMessageSafe();
await keychain.Clear(host, false);
return(new LoginResultData(LoginResultCodes.Failed, message, host));
}
catch (Exception e)
{
logger.Warning(e, "Login Exception");
// Some enterprise instances don't support OAUTH, so fall back to using the
// supplied password - on instances that don't support OAUTH the user should
// be using a personal access token as the password.
if (EnterpriseWorkaround(host, e))
{
auth = new ApplicationAuthorization(password);
}
else
{
await keychain.Clear(host, false);
return(new LoginResultData(LoginResultCodes.Failed, Localization.LoginFailed, host));
}
}
keychain.SetToken(host, auth.Token);
await keychain.Save(host);
return(new LoginResultData(LoginResultCodes.Success, "Success", host));
}
