public WebXlob(string uri, NameValueCollection customHeaders, ICredentials credentials)
{
if (uri == null) throw new ArgumentNullException("uri");
this.uri = new Uri(uri);
this.headers = customHeaders;
this.credentials = credentials;
}
public static HttpClientHandler CreateClientHandler(string serviceUrl, ICredentials credentials)
{
if (serviceUrl == null)
{
throw new ArgumentNullException("serviceUrl");
}
// Set up our own HttpClientHandler and configure it
HttpClientHandler clientHandler = new HttpClientHandler();
if (credentials != null)
{
// Set up credentials cache which will handle basic authentication
CredentialCache credentialCache = new CredentialCache();
// Get base address without terminating slash
string credentialAddress = new Uri(serviceUrl).GetLeftPart(UriPartial.Authority).TrimEnd(uriPathSeparator);
// Add credentials to cache and associate with handler
NetworkCredential networkCredentials = credentials.GetCredential(new Uri(credentialAddress), "Basic");
credentialCache.Add(new Uri(credentialAddress), "Basic", networkCredentials);
clientHandler.Credentials = credentialCache;
clientHandler.PreAuthenticate = true;
}
// Our handler is ready
return clientHandler;
}
public void SetUp()
{
_successor = MockRepository.GenerateStub<IHandler>();
_handler = new OptionsHandler(_successor);
_endpointDetails = MockRepository.GenerateStub<IEndpointDetails>();
_credentials = MockRepository.GenerateStub<ICredentials>();
}
public BuildFetcher(String serverAddress, String projectName, ICredentials credentials)
{
this.projectName = projectName;
tfsServer = new TeamFoundationServer(serverAddress, credentials);
tfsServer.Authenticate();
buildServer = (IBuildServer) tfsServer.GetService(typeof (IBuildServer));
}
public RavenCountersClient(string serverUrl, string counterStorageName, ICredentials credentials = null, string apiKey = null)
{
try
{
ServerUrl = serverUrl;
if (ServerUrl.EndsWith("/"))
ServerUrl = ServerUrl.Substring(0, ServerUrl.Length - 1);
CounterStorageName = counterStorageName;
Credentials = credentials ?? CredentialCache.DefaultNetworkCredentials;
ApiKey = apiKey;
convention = new CounterConvention();
//replicationInformer = new RavenFileSystemReplicationInformer(convention, JsonRequestFactory);
//readStripingBase = replicationInformer.GetReadStripingBase();
//todo: implement remote counter changes
//notifications = new RemoteFileSystemChanges(serverUrl, apiKey, credentials, jsonRequestFactory, convention, replicationInformer, () => { });
InitializeSecurity();
}
catch (Exception)
{
Dispose();
throw;
}
}
public IPromise<string> Login(ICredentials credentials, bool async)
{
_lastCredentials = credentials;
var mapping = _mappings.First(m => m.Databases.Contains(credentials.Database));
_current = mapping.Connection;
return _current.Login(credentials, async);
}
public static void SetupEnvironment(string url,
ICredentials credentials,
string path)
{
if (string.IsNullOrEmpty(url))
throw new ArgumentException("url");
if (string.IsNullOrEmpty(path))
throw new ArgumentException("path");
ReportingService2010 service = ReportingService2010TestEnvironment.GetReportingService(url, credentials);
if (ReportingService2010TestEnvironment.ItemExists(service, path, "Folder"))
service.DeleteItem(path);
// Create the parent (base) folder where the integration tests will be written to (e.g. /DEST_SSRSMigrate_Tests)
ReportingService2010TestEnvironment.CreateFolderFromPath(service, path);
// Create folder structure
ReportingService2010TestEnvironment.CreateFolders(service, path);
// Create the the data sources
ReportingService2010TestEnvironment.CreateDataSources(service, path);
// Create the the reports
//ReportingService2010TestEnvironment.CreateReports(service, path);
}
/// <summary>
/// Modifies the request to ensure that the authentication requirements are met.
/// </summary>
/// <param name="client">Client executing this request</param>
/// <param name="request">Request to authenticate</param>
/// <param name="credentials">The credentials used for the authentication</param>
/// <returns>The task the authentication is performed on</returns>
public override async Task PreAuthenticate(IHttpClient client, IHttpRequestMessage request, ICredentials credentials)
{
// When the authorization failed or when the Authorization header is missing, we're just adding it (again) with the
// new AccessToken.
var authHeader = $"{_tokenType} {await Client.GetCurrentToken()}";
request.SetAuthorizationHeader(AuthHeader.Www, authHeader);
}
public void Login(ICredentials credentials)
{
_lastCredentials = credentials;
var mapping = _mappings.First(m => m.Databases.Contains(credentials.Database));
_current = mapping.Connection;
_current.Login(credentials);
}
/// <summary>
/// Make a web request to the given URL using the given credentials, and download the response into a file.
/// </summary>
/// <param name="uri">download url</param>
/// <param name="cred">credentials to access url</param>
/// <param name="path">file path</param>
public static void Download(Uri uri, ICredentials cred, string path)
{
var request = (HttpWebRequest) WebRequest.Create(uri);
request.Timeout = 60*1000;
request.Method = "GET";
request.KeepAlive = true;
request.Credentials = cred;
HttpWebResponse response = null;
try
{
response = (HttpWebResponse) request.GetResponse();
using (Stream rcvd = response.GetResponseStream())
{
using (FileStream store = File.Create(path))
{
int n = 64*1024;
var buf = new byte[n];
while ((n = rcvd.Read(buf, 0, n)) > 0)
{
store.Write(buf, 0, n);
}
}
}
}
finally
{
if (response != null) response.Close();
}
}
public Authorization Authenticate (string challenge, WebRequest webRequest, ICredentials credentials)
{
if (authObject == null)
return null;
return authObject.Authenticate (challenge, webRequest, credentials);
}
/// <summary>
/// Retrieves the latest changeset ID associated with a path
/// </summary>
/// <param name="localPath">A path on the local filesystem</param>
/// <param name="credentials">Credentials used to authenticate against the serer</param>
/// <returns></returns>
public int GetLatestChangesetId(string localPath, ICredentials credentials)
{
int latestChangesetId = 0;
string server;
Workstation workstation = new Workstation(versionControlClientAssembly);
WorkspaceInfo workspaceInfo = workstation.GetLocalWorkspaceInfo(localPath);
server = workspaceInfo.ServerUri.ToString();
VersionControlServer sourceControl = new VersionControlServer(clientAssembly, versionControlClientAssembly, server, credentials);
Workspace workspace = sourceControl.GetWorkspace(localPath);
WorkspaceVersionSpec workspaceVersionSpec = new WorkspaceVersionSpec(versionControlClientAssembly, workspace);
VersionSpec versionSpec = new VersionSpec(versionControlClientAssembly);
RecursionType recursionType = new RecursionType(versionControlClientAssembly);
IEnumerable history = sourceControl.QueryHistory(localPath, versionSpec.Latest, recursionType.Full, workspaceVersionSpec);
IEnumerator historyEnumerator = history.GetEnumerator();
Changeset latestChangeset = new Changeset(versionControlClientAssembly);
if (historyEnumerator.MoveNext())
{
latestChangeset = new Changeset(versionControlClientAssembly, historyEnumerator.Current);
}
if (latestChangeset.Instance != null)
{
latestChangesetId = latestChangeset.ChangesetId;
}
return latestChangesetId;
}
public ClientConnectionManager(HazelcastClient client)
{
_client = client;
var config = client.GetClientConfig();
_networkConfig = config.GetNetworkConfig();
config.GetNetworkConfig().IsRedoOperation();
_credentials = config.GetCredentials();
//init socketInterceptor
var sic = config.GetNetworkConfig().GetSocketInterceptorConfig();
if (sic != null && sic.IsEnabled())
{
//TODO Socket interceptor
throw new NotImplementedException("Socket Interceptor not yet implemented.");
}
_socketInterceptor = null;
var timeout = EnvironmentUtil.ReadEnvironmentVar("hazelcast.client.invocation.timeout.seconds");
if (timeout > 0)
{
ThreadUtil.TaskOperationTimeOutMilliseconds = timeout.Value*1000;
}
_heartbeatTimeout = EnvironmentUtil.ReadEnvironmentVar("hazelcast.client.heartbeat.timeout") ??
_heartbeatTimeout;
_heartbeatInterval = EnvironmentUtil.ReadEnvironmentVar("hazelcast.client.heartbeat.interval") ??
_heartbeatInterval;
}
/// <summary>
/// Initializes a new instance of the <see cref="AsyncServerClient"/> class.
/// </summary>
/// <param name="url">The URL.</param>
/// <param name="convention">The convention.</param>
/// <param name="credentials">The credentials.</param>
public AsyncServerClient(string url, DocumentConvention convention, ICredentials credentials, HttpJsonRequestFactory jsonRequestFactory)
{
this.url = url;
this.jsonRequestFactory = jsonRequestFactory;
this.convention = convention;
this.credentials = credentials;
}
public ArcGISLegendResponse GetLegendInfo(string serviceUrl, ICredentials credentials = null)
{
_webRequest = CreateRequest(serviceUrl, credentials);
var response = _webRequest.GetSyncResponse(_timeOut);
_legendResponse = GetLegendResponseFromWebresponse(response);
return _legendResponse;
}
public void Login(ICredentials credentials, Action<IStatus> onCompleteCallback)
{
if (credentials.Service.OAuth == null)
{
credentials.Service
.Login(
credentials.UserName,
credentials.Password,
status =>
{
if (status.Success)
{
_isSignedOn = true;
Accounts.Add(credentials);
}
if (onCompleteCallback == null)
return;
onCompleteCallback(status);
});
}
else
{
var status = new Status {Success = credentials.Service.OAuth.IsValid};
onCompleteCallback(status);
}
}
static Authorization InternalAuthenticate (WebRequest webRequest, ICredentials credentials)
{
HttpWebRequest request = webRequest as HttpWebRequest;
if (request == null || credentials == null)
return null;
NetworkCredential cred = credentials.GetCredential (request.AuthUri, "basic");
if (cred == null)
return null;
string userName = cred.UserName;
if (userName == null || userName == "")
return null;
string password = cred.Password;
string domain = cred.Domain;
byte [] bytes;
// If domain is set, MS sends "domain\user:password".
if (domain == null || domain == "" || domain.Trim () == "")
bytes = GetBytes (userName + ":" + password);
else
bytes = GetBytes (domain + "\\" + userName + ":" + password);
string auth = "Basic " + Convert.ToBase64String (bytes);
return new Authorization (auth);
}
private Stream GetNonFileStream( Uri uri, ICredentials credentials ) {
WebRequest req = WebRequest.Create( uri );
if ( credentials != null ) {
req.Credentials = credentials;
}
WebResponse resp = req.GetResponse();
HttpWebRequest webReq = req as HttpWebRequest;
if ( webReq != null ) {
lock ( this ) {
if ( connections == null ) {
connections = new Hashtable();
}
OpenedHost openedHost = (OpenedHost)connections[webReq.Address.Host];
if ( openedHost == null ) {
openedHost = new OpenedHost();
}
if ( openedHost.nonCachedConnectionsCount < webReq.ServicePoint.ConnectionLimit - 1 ) {
// we are not close to connection limit -> don't cache the stream
if ( openedHost.nonCachedConnectionsCount == 0 ) {
connections.Add( webReq.Address.Host, openedHost );
}
openedHost.nonCachedConnectionsCount++;
return new XmlRegisteredNonCachedStream( resp.GetResponseStream(), this, webReq.Address.Host );
}
else {
// cache the stream and save the connection for the next request
return new XmlCachedStream( resp.ResponseUri, resp.GetResponseStream() );
}
}
}
else {
return resp.GetResponseStream();
}
}
/// <summary>
/// To be called by a deriving class when a request is being executed. This method defines the
/// basic workflow of an HTTP REST, which can be customized by a deriving class via virtual
/// method overrides
/// </summary>
/// <param name="url">HTTP URL of the request</param>
/// <param name="credentials">Credentials to use for the HTTP request. This parameter is optional
/// and null can be passed in if there's no credentials</param>
protected void SendRequest( string url,
ICredentials credentials )
{
try
{
ServicePointManager.Expect100Continue = false;
_httpRequest = (HttpWebRequest)WebRequest.Create( url );
_httpRequest.Credentials = credentials;
_httpRequest.Method = GetHttpMethod();
FillInHttpRequest( _httpRequest );
AddBodyToRequest( GetRequestBody() );
var response = (HttpWebResponse)_httpRequest.GetResponse();
HandleResponse( response, response.GetResponseStream() );
response.Close();
}
catch( WebException ex )
{
HandleHttpFailure( ex );
}
}
public static TfsConnection GetTfsConfigurationServer(string uri, ICredentials credentials)
{
// constructor
var tfsMock = _getTfsMock(uri, credentials);
return tfsMock.Object;
}
/// <summary>
/// Initializes a new instance of the <see cref="MailKit.Security.SaslMechanismLogin"/> class.
/// </summary>
/// <remarks>
/// Creates a new LOGIN SASL context.
/// </remarks>
/// <param name="uri">The URI of the service.</param>
/// <param name="encoding">The encoding to use for the user's credentials.</param>
/// <param name="credentials">The user's credentials.</param>
/// <exception cref="System.ArgumentNullException">
/// <para><paramref name="uri"/> is <c>null</c>.</para>
/// <para>-or-</para>
/// <para><paramref name="encoding"/> is <c>null</c>.</para>
/// <para>-or-</para>
/// <para><paramref name="credentials"/> is <c>null</c>.</para>
/// </exception>
public SaslMechanismLogin (Uri uri, Encoding encoding, ICredentials credentials) : base (uri, credentials)
{
if (encoding == null)
throw new ArgumentNullException (nameof (encoding));
this.encoding = encoding;
}
public static HttpClientHandler CreateClientHandler(string serviceUrl, ICredentials credentials, bool useCookies = false)
{
if (serviceUrl == null)
{
throw new ArgumentNullException("serviceUrl");
}
// Set up our own HttpClientHandler and configure it
HttpClientHandler clientHandler = new HttpClientHandler();
if (credentials != null)
{
// Set up credentials cache which will handle basic authentication
CredentialCache credentialCache = new CredentialCache();
// Get base address without terminating slash
string credentialAddress = new Uri(serviceUrl).GetLeftPart(UriPartial.Authority).TrimEnd(uriPathSeparator);
// Add credentials to cache and associate with handler
NetworkCredential networkCredentials = credentials.GetCredential(new Uri(credentialAddress), "Basic");
credentialCache.Add(new Uri(credentialAddress), "Basic", networkCredentials);
clientHandler.Credentials = credentialCache;
clientHandler.PreAuthenticate = true;
}
// HttpClient's default UseCookies is true (meaning always roundtripping cookie back)
// However, our api will default to false to cover multiple instance scenarios
clientHandler.UseCookies = useCookies;
// Our handler is ready
return clientHandler;
}
public WebXlob(Uri uri, NameValueCollection customHeaders, ICredentials credentials)
{
if (uri == null) throw new ArgumentNullException("uri");
_uri = uri;
_headers = customHeaders;
_credentials = credentials;
}
/// <summary>
/// Sends a get request to the server
/// </summary>
public string NewGetRequest(string method, IDictionary<string, string> keyValues, ICredentials credentials)
{
StringBuilder url = new StringBuilder();
url.Append(_baseUrl);
url.Append(method);
url.Append("?");
bool first = true;
foreach (string key in keyValues.Keys)
{
if (!first)
url.Append("&");
url.Append(key);
url.Append("=");
url.Append(keyValues[key]);
first = false;
}
HttpWebRequest request = WebRequest.Create(url.ToString()) as HttpWebRequest;
if (credentials != null)
request.Credentials = credentials;
// Get response
using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)
{
// Get the response stream
StreamReader reader = new StreamReader(response.GetResponseStream());
// Console application output
return reader.ReadToEnd();
}
}
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"));
}
internal void PreAuthIfNeeded(HttpWebRequest httpWebRequest, ICredentials authInfo) {
//
// attempt to do preauth, if needed
//
GlobalLog.Print("AuthenticationState#" + ValidationHelper.HashString(this) + "::PreAuthIfNeeded() TriedPreAuth:" + TriedPreAuth.ToString() + " authInfo:" + ValidationHelper.HashString(authInfo));
if (!TriedPreAuth) {
TriedPreAuth = true;
if (authInfo!=null) {
PrepareState(httpWebRequest);
Authorization preauth = null;
try {
preauth = AuthenticationManager.PreAuthenticate(httpWebRequest, authInfo);
GlobalLog.Print("AuthenticationState#" + ValidationHelper.HashString(this) + "::PreAuthIfNeeded() preauth:" + ValidationHelper.HashString(preauth));
if (preauth!=null && preauth.Message!=null) {
GlobalLog.Print("AuthenticationState#" + ValidationHelper.HashString(this) + "::PreAuthIfNeeded() setting TriedPreAuth to Complete:" + preauth.Complete.ToString());
UniqueGroupId = preauth.ConnectionGroupId;
httpWebRequest.Headers.Set(AuthorizationHeader, preauth.Message);
}
}
catch (Exception exception) {
GlobalLog.Print("AuthenticationState#" + ValidationHelper.HashString(this) + "::PreAuthIfNeeded() PreAuthenticate() returned exception:" + exception.Message);
}
}
}
}
public static HttpWebRequest ToRequest(this string url, IDictionary<string, string> operationsHeaders, ICredentials credentials, string verb)
{
var request = (HttpWebRequest)WebRequestCreator.ClientHttp.Create( url.ToUri() );
request.WithOperationHeaders(operationsHeaders);
request.Method = verb;
return request;
}
public Stream GetStream(Uri uri, ICredentials credentials, int? timeout, int? byteLimit)
{
WebRequest request = WebRequest.Create(uri);
#if !PORTABLE
if (timeout != null)
request.Timeout = timeout.Value;
#endif
if (credentials != null)
request.Credentials = credentials;
WebResponse response;
#if PORTABLE
Task<WebResponse> result = Task.Factory.FromAsync(
request.BeginGetResponse,
new Func<IAsyncResult, WebResponse>(request.EndGetResponse), null);
result.ConfigureAwait(false);
response = result.Result;
#else
response = request.GetResponse();
#endif
Stream responseStream = response.GetResponseStream();
if (timeout != null)
responseStream.ReadTimeout = timeout.Value;
if (byteLimit != null)
return new LimitedStream(responseStream, byteLimit.Value);
return responseStream;
}
// ===========================================================================================================
/// <summary>
/// Launches the current sequence by executing all it's templates
/// </summary>
/// <param name="credentials">The credentials required for creating the client context</param>
/// <param name="templateProvider">The <b>XMLTemplatePRovider</b> that is mapped to the client's working directory</param>
// ===========================================================================================================
public void Launch(ICredentials credentials, XMLTemplateProvider templateProvider)
{
if(!this.Ignore)
{
logger.Info("Launching sequence '{0}' ({1})", this.Name, this.Description);
using (ClientContext ctx = new ClientContext(this.WebUrl))
{
// --------------------------------------------------
// Sets the context with the provided credentials
// --------------------------------------------------
ctx.Credentials = credentials;
ctx.RequestTimeout = Timeout.Infinite;
// --------------------------------------------------
// Loads the full web for futur references (providers)
// --------------------------------------------------
Web web = ctx.Web;
ctx.Load(web);
ctx.ExecuteQueryRetry();
// --------------------------------------------------
// Launches the templates
// --------------------------------------------------
foreach (Template template in this.Templates)
{
template.Apply(web, templateProvider);
}
}
}
else
{
logger.Info("Ignoring sequence '{0}' ({1})", this.Name, this.Description);
}
}
public static IEnumerable<XElement> GetSearchResult(string SearchQuery, int PageSize, int PageCount, string SearchServiceUrl, string Scope, ICredentials Credentials)
{
var query = @"SELECT WorkId,Rank,Title,Author,Size,Path,Write,HitHighlightedSummary FROM Scope() WHERE freetext('" + SearchQuery.Replace('\'', ' ') + @"')";
if (!string.IsNullOrEmpty(Scope))
{
query = query + string.Format(@"AND ""Scope""='{0}'", Scope);
}
XNamespace ns = "urn:Microsoft.Search.Query";
XElement queryPacket = new XElement(ns + "QueryPacket",
new XElement(ns + "Query",
new XElement(ns + "Context",
new XElement(ns + "QueryText",
new XAttribute("language", CultureInfo.CurrentCulture.ToString()),
new XAttribute("type", "MSSQLFT"),
query
)
), new XElement(ns + "TrimDuplicates", false),
new XElement(ns + "Range",
new XElement(ns + "StartAt", (PageCount - 1) * PageSize + 1),
new XElement(ns + "Count", PageSize)
)
)
);
QueryService queryService = new QueryService();
queryService.Url = SearchServiceUrl;
queryService.Credentials = Credentials;
string queryResultsString = queryService.Query(queryPacket.ToString());
return new List<XElement>() {
XElement.Parse(CleanInvalidXmlChars(queryResultsString))
};
}
public Connection(Uri url, NetworkCredential networkCredential)
{
Url = url;
Credential = networkCredential;
}
public DummyModuleIdentityLifecycleManager(string hostName, string gatewayHostname, string deviceId, string moduleId, ICredentials credentials)
{
this.hostName = hostName;
this.gatewayHostname = gatewayHostname;
this.deviceId = deviceId;
this.moduleId = moduleId;
this.credentials = credentials;
}
/// <summary>
/// Initializes a new instance of the <see cref="WebCredentials"/> class using
/// specified credentials.
/// </summary>
/// <param name="credentials">Credentials to use.</param>
public WebCredentials(ICredentials credentials)
{
EwsUtilities.ValidateParam(credentials, "credentials");
this.credentials = credentials;
}
protected HttpWebResponse PostEvent <T>(T data, ICredentials credentials = null)
{
return(MakeArrayEventsPost(
TestStream, new[] { new { EventId = Guid.NewGuid(), EventType = "event-type", Data = data } }, credentials));
}
public WebProxy(string Address, bool BypassOnLocal, string[] BypassList, ICredentials Credentials)
: this(CreateProxyUri(Address), BypassOnLocal, BypassList, Credentials)
{
}
private async Task CreateAndValidateRequest(HttpClientHandler handler, Uri url, HttpStatusCode expectedStatusCode, ICredentials credentials)
{
handler.Credentials = credentials;
using (HttpClient client = CreateHttpClient(handler))
using (HttpResponseMessage response = await client.GetAsync(url))
{
Assert.Equal(expectedStatusCode, response.StatusCode);
}
}
public NoBypassWebProxy(Uri uri, ICredentials credentials = null)
{
_uri = uri ?? throw new ArgumentNullException(nameof(uri));
Credentials = credentials ?? new NetworkCredential("", "");
}
private static IAsyncDatabaseCommands SetupCommandsAsync(IAsyncDatabaseCommands databaseCommands, string database, ICredentials credentialsForSession, OpenSessionOptions options)
{
if (database != null)
{
databaseCommands = databaseCommands.ForDatabase(database);
}
if (credentialsForSession != null)
{
databaseCommands = databaseCommands.With(credentialsForSession);
}
if (options.ForceReadFromMaster)
{
databaseCommands.ForceReadFromMaster();
}
return(databaseCommands);
}
public Stream GetStream(Uri uri, ICredentials credentials, int?timeout, int?byteLimit)
{
throw new Exception("Could not find");
}
public Connection(Uri url, string username, string password)
{
Url = url;
Credential = new NetworkCredential(username, password);
}
/// <summary>
/// Метод отправки коллекции писем
/// </summary>
/// <param name="messages">коллекция писем для отправки - объектов типа MailMessage</param>
/// <param name="sMailBoxUrl">url почтого ящика с которого отправляется письмо, например http://dm.croc.ru/exchange/DAlexandrov</param>
public static void Send(ICollection messages, string sMailBoxUrl, int nTimeout, ICredentials credentials)
{
if (0 == messages.Count)
{
return;
}
string draftsUrl = sMailBoxUrl + "/drafts/";
StringBuilder mailToDeliver = new StringBuilder();
mailToDeliver.Append("<?xml version=\"1.0\"?><D:move xmlns:D=\"DAV:\"><D:target>");
WebDAVRequest req;
foreach (MailMessage m in messages)
{
///
string mailUrl = draftsUrl + Guid.NewGuid().ToString("N") + ".eml";
req = WebDAVRequest.Create(WebDAVMethods.PROPPATCH, mailUrl, m.ToXmlByteArray(), credentials);
req.SetTimeout(nTimeout);
req.Send();
mailToDeliver.AppendFormat("<D:href>{0}</D:href>", mailUrl);
///
}
mailToDeliver.Append("</D:target></D:move>");
///
byte[] data = Encoding.UTF8.GetBytes(mailToDeliver.ToString());
req = WebDAVRequest.Create(WebDAVMethods.BMOVE, draftsUrl, credentials);
req.SetTimeout(nTimeout);
req.AddHeader("Destination", sMailBoxUrl + "/##DavMailSubmissionURI##/");
req.AddHeader("Saveinsent", "f");
req.WriteContent(data);
req.Send();
}
public ICredentials GetCredentials(Uri uri, IWebProxy proxy, CredentialType credentialType, ICredentials existingCredentials, bool retrying)
{
bool result = false;
DispatchService.GuiSyncDispatch(() => {
using (var ns = new NSAutoreleasePool()) {
var message = string.Format("{0} needs {1} credentials to access {2}.", BrandingService.ApplicationName,
credentialType == CredentialType.ProxyCredentials ? "proxy" : "request", uri.Host);
NSAlert alert = NSAlert.WithMessage("Credentials Required", "OK", "Cancel", null, message);
alert.Icon = NSApplication.SharedApplication.ApplicationIconImage;
NSView view = new NSView(new RectangleF(0, 0, 313, 91));
var creds = Utility.GetCredentialsForUriFromICredentials(uri, existingCredentials);
var usernameLabel = new NSTextField(new RectangleF(17, 55, 71, 17))
{
Identifier = "usernameLabel",
StringValue = "Username:"******"Password:",
Alignment = NSTextAlignment.Right,
Editable = false,
Bordered = false,
DrawsBackground = false,
Bezeled = false,
Selectable = false,
};
view.AddSubview(passwordLabel);
var passwordInput = new NSSecureTextField(new RectangleF(93, 20, 200, 22));
passwordInput.StringValue = creds != null ? creds.Password : string.Empty;
view.AddSubview(passwordInput);
alert.AccessoryView = view;
result = alert.RunModal() == 1;
username = usernameInput.StringValue;
password = passwordInput.StringValue;
}
});
return(result ? new NetworkCredential(username, password) : null);
}
/// <summary> /// Adds an <c>Authenticator</c> to the <c>RestSharp.RestClient</c>. /// </summary> /// <remarks> /// Authenticators are used to interact with the DNSimple API. They can /// be either HTTPBasic (email and password) or OAuth2 tokens. /// </remarks> /// <param name="credentials">The credentials containing the authenticator to be used</param> /// <see cref="ICredentials"/> /// <see cref="RestSharp.Authenticators.IAuthenticator"/> public virtual void AddAuthenticator(ICredentials credentials) => RestClient.Authenticator = credentials.Authenticator;
/// <summary>
/// Методы формирования http-запроса
/// </summary>
public static WebDAVRequest Create(string sMethod, string sUrl, byte[] data, ICredentials credentials)
{
WebDAVRequest req = Create(sMethod, sUrl, credentials);
req.WriteContent(data);
return(req);
}
static void Save(ICredentials credentials, string pin);
public Authorization PreAuthenticate(WebRequest request, ICredentials credentials)
{
throw new NotImplementedException();
}
public DeployManager(Uri urlToWeb, ICredentials credentials, bool isSharePointOnline)
{
_urlToWeb = urlToWeb;
_credentials = credentials;
_isSharePointOnline = isSharePointOnline;
}
static void Delete(ICredentials credentials);
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
HttpResponseMessage response = null;
ICredentials promptCredentials = null;
var configuration = request.GetOrCreateConfiguration();
// Authorizing may take multiple attempts
while (true)
{
// Clean up any previous responses
if (response != null)
{
response.Dispose();
}
// store the auth state before sending the request
var beforeLockVersion = _credentials.Version;
response = await base.SendAsync(request, cancellationToken);
if (_credentialService == null)
{
return(response);
}
if (response.StatusCode == HttpStatusCode.Unauthorized ||
(configuration.PromptOn403 && response.StatusCode == HttpStatusCode.Forbidden))
{
IList <Stopwatch> stopwatches = null;
if (request.Properties.TryGetValue(HttpRetryHandler.StopwatchPropertyName, out var value))
{
stopwatches = value as IList <Stopwatch>;
if (stopwatches != null)
{
foreach (var stopwatch in stopwatches)
{
stopwatch.Stop();
}
}
}
promptCredentials = await AcquireCredentialsAsync(
response.StatusCode,
beforeLockVersion,
configuration.Logger,
cancellationToken);
if (stopwatches != null)
{
foreach (var stopwatch in stopwatches)
{
stopwatch.Start();
}
}
if (promptCredentials == null)
{
return(response);
}
continue;
}
if (promptCredentials != null)
{
CredentialsSuccessfullyUsed(_packageSource.SourceUri, promptCredentials);
}
return(response);
}
}
/// <summary>
/// Get response from the given uri with given credentials
/// </summary>
/// <param name="uri">uri</param>
/// <param name="credentials">credentials</param>
/// <param name="callbackFunc">callback function</param>
public static void GetResponseAsync(String uri, Action <String> callbackFunc, ICredentials credentials = null)
{
if (uri == null || uri.Length == 0)
{
throw new Exception("Must supply valid URI!");
}
WebClient client = new WebClient(); WebRequest.Create(uri);
if (credentials != null)
{
client.Credentials = credentials;
}
client.DownloadStringCompleted += (s, e) =>
{
callbackFunc(e.Result);
};
client.DownloadStringAsync(new Uri(uri, UriKind.Absolute));
}
public HttpClient CreateHttpClient(string endpoint, ICredentials credentials)
{
return(CreateHttpClient(endpoint, ClientFactory.CreateHttpClientHandler(endpoint, credentials)));
}
/// <summary>
/// Sets the ProxyCredentials property.
/// </summary>
/// <param name="proxyCredentials">ProxyCredentials property</param>
/// <returns>this instance</returns>
public AmazonSimpleNotificationServiceConfig WithProxyCredentials(ICredentials proxyCredentials)
{
this.proxyCredentials = proxyCredentials;
return(this);
}
private void DownloadPackage(string packageId, NuGetVersion version, Uri feedUri, ICredentials feedCredentials, string cacheDirectory, int maxDownloadAttempts, TimeSpan downloadAttemptBackoff, out LocalNuGetPackage downloaded, out string downloadedTo)
{
Log.Info("Downloading NuGet package {0} {1} from feed: '{2}'", packageId, version, feedUri);
Log.VerboseFormat("Downloaded package will be stored in: '{0}'", cacheDirectory);
fileSystem.EnsureDirectoryExists(cacheDirectory);
fileSystem.EnsureDiskHasEnoughFreeSpace(cacheDirectory);
var fullPathToDownloadTo = GetFilePathToDownloadPackageTo(cacheDirectory, packageId, version.ToString());
var downloader = new NuGetPackageDownloader();
downloader.DownloadPackage(packageId, version, feedUri, feedCredentials, fullPathToDownloadTo, maxDownloadAttempts, downloadAttemptBackoff);
downloaded = new LocalNuGetPackage(fullPathToDownloadTo);
downloadedTo = fullPathToDownloadTo;
CheckWhetherThePackageHasDependencies(downloaded.Metadata);
}
private void CredentialsSuccessfullyUsed(Uri uri, ICredentials credentials)
{
HttpHandlerResourceV3.CredentialsSuccessfullyUsed?.Invoke(uri, credentials);
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataClientSettings"/> class.
/// </summary>
/// <param name="baseUri">The URL address.</param>
/// <param name="credentials">The client credentials.</param>
public ODataClientSettings(string baseUri, ICredentials credentials = null)
{
this.BaseUri = new Uri(baseUri);
this.Credentials = credentials;
}
public void DownloadPackage(string packageId, NuGetVersion version, string feedId, Uri feedUri, ICredentials feedCredentials, bool forcePackageDownload, int maxDownloadAttempts, TimeSpan downloadAttemptBackoff, out string downloadedTo, out string hash, out long size)
{
var cacheDirectory = GetPackageRoot(feedId);
LocalNuGetPackage downloaded = null;
downloadedTo = null;
if (!forcePackageDownload)
{
AttemptToGetPackageFromCache(packageId, version, cacheDirectory, out downloaded, out downloadedTo);
}
if (downloaded == null)
{
DownloadPackage(packageId, version, feedUri, feedCredentials, cacheDirectory, maxDownloadAttempts, downloadAttemptBackoff, out downloaded, out downloadedTo);
}
else
{
Log.VerboseFormat("Package was found in cache. No need to download. Using file: '{0}'", downloadedTo);
}
size = fileSystem.GetFileSize(downloadedTo);
string packageHash = null;
downloaded.GetStream(stream => packageHash = HashCalculator.Hash(stream));
hash = packageHash;
}
/// <summary>
/// Returns a new <see cref="IDatabaseCommands"/> using the specified credentials
/// </summary>
/// <param name="credentialsForSession">The credentials for session.</param>
/// <returns></returns>
public IDatabaseCommands With(ICredentials credentialsForSession)
{
return(new ServerClient((AsyncServerClient)asyncServerClient.With(credentialsForSession))); //TODO This cast is bad
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataClientSettings"/> class.
/// </summary>
/// <param name="baseUri">The URL address.</param>
/// <param name="credentials">The client credentials.</param>
public ODataClientSettings(Uri baseUri, ICredentials credentials = null)
{
this.BaseUri = baseUri;
this.Credentials = credentials;
}
/// <summary>
/// Create an instance of the specified SASL mechanism using the uri and credentials.
/// </summary>
/// <remarks>
/// If unsure that a particular SASL mechanism is supported, you should first call
/// <see cref="IsSupported"/>.
/// </remarks>
/// <returns>An instance of the requested SASL mechanism if supported; otherwise <c>null</c>.</returns>
/// <param name="mechanism">The name of the SASL mechanism.</param>
/// <param name="uri">The URI of the service to authenticate against.</param>
/// <param name="credentials">The user's credentials.</param>
/// <exception cref="System.ArgumentNullException">
/// <para><paramref name="mechanism"/> is <c>null</c>.</para>
/// <para>-or-</para>
/// <para><paramref name="uri"/> is <c>null</c>.</para>
/// <para>-or-</para>
/// <para><paramref name="credentials"/> is <c>null</c>.</para>
/// </exception>
public static SaslMechanism Create(string mechanism, Uri uri, ICredentials credentials)
{
return(Create(mechanism, uri, Encoding.UTF8, credentials));
}
/// <summary> /// Authenticate by impersonation, using an existing <c>ICredentials</c> instance /// </summary> /// <param name="credentials"></param> public NtlmAuthenticator(ICredentials credentials) => this.credentials = credentials ?? throw new ArgumentNullException(nameof(credentials));
