protected DirectResponse(OpenIdRelyingParty relyingParty, ServiceEndpoint provider, IDictionary<string, string> args) {
if (relyingParty == null) throw new ArgumentNullException("relyingParty");
if (provider == null) throw new ArgumentNullException("provider");
if (args == null) throw new ArgumentNullException("args");
RelyingParty = relyingParty;
Provider = provider;
Args = args;
// Make sure that the OP fulfills the required OpenID version.
// We don't use Provider.Protocol here because that's just a cache of
// what we _thought_ the OP would support, and our purpose is to double-check this.
ProtocolVersion detectedProtocol = Protocol.DetectFromDirectResponse(args).ProtocolVersion;
if (detectedProtocol < relyingParty.Settings.MinimumRequiredOpenIdVersion) {
throw new OpenIdException(string.Format(CultureInfo.CurrentCulture,
Strings.MinimumOPVersionRequirementNotMet,
Protocol.Lookup(relyingParty.Settings.MinimumRequiredOpenIdVersion).Version,
Protocol.Lookup(detectedProtocol).Version));
}
if (Logger.IsErrorEnabled) {
if (provider.Protocol.QueryDeclaredNamespaceVersion != null) {
if (!Args.ContainsKey(Protocol.openidnp.ns)) {
Logger.ErrorFormat("Direct response from provider lacked the {0} key.", Protocol.openid.ns);
} else if (Args[Protocol.openidnp.ns] != Protocol.QueryDeclaredNamespaceVersion) {
Logger.ErrorFormat("Direct response from provider for key {0} was '{1}' rather than '{2}'.",
Protocol.openid.ns, Args[Protocol.openidnp.ns], Protocol.QueryDeclaredNamespaceVersion);
}
}
}
}
public IDictionary<string, string> SendDirectMessageAndGetResponse(ServiceEndpoint provider, IDictionary<string, string> fields)
{
OnSending(provider, fields);
var results = channel.SendDirectMessageAndGetResponse(provider, fields);
OnReceiving(provider, results);
return results;
}
protected virtual void OnReceiving(ServiceEndpoint provider, IDictionary<string, string> fields)
{
var receiving = Receiving;
if (receiving != null) {
receiving(provider, fields);
}
}
public string GetBuildDirectoryHashKey(IExecutionContext executionContext, ServiceEndpoint endpoint)
{
// Validate parameters.
Trace.Entering();
ArgUtil.NotNull(executionContext, nameof(executionContext));
ArgUtil.NotNull(executionContext.Variables, nameof(executionContext.Variables));
ArgUtil.NotNull(endpoint, nameof(endpoint));
ArgUtil.NotNull(endpoint.Url, nameof(endpoint.Url));
// Calculate the hash key.
const string Format = "{{{{ \r\n \"system\" : \"build\", \r\n \"collectionId\" = \"{0}\", \r\n \"definitionId\" = \"{1}\", \r\n \"repositoryUrl\" = \"{2}\", \r\n \"sourceFolder\" = \"{{0}}\",\r\n \"hashKey\" = \"{{1}}\"\r\n}}}}";
string hashInput = string.Format(
CultureInfo.InvariantCulture,
Format,
executionContext.Variables.System_CollectionId,
executionContext.Variables.System_DefinitionId,
endpoint.Url.AbsoluteUri);
using (SHA1 sha1Hash = SHA1.Create())
{
byte[] data = sha1Hash.ComputeHash(Encoding.UTF8.GetBytes(hashInput));
StringBuilder hexString = new StringBuilder();
for (int i = 0; i < data.Length; i++)
{
hexString.Append(data[i].ToString("x2"));
}
return hexString.ToString();
}
}
public void ReturnsCorrectHashKey()
{
using (TestHostContext tc = new TestHostContext(this))
{
// Arrange.
var executionContext = new Mock<IExecutionContext>();
List<string> warnings;
executionContext
.Setup(x => x.Variables)
.Returns(new Variables(tc, copy: new Dictionary<string, string>(), maskHints: new List<MaskHint>(), warnings: out warnings));
executionContext.Object.Variables.Set(Constants.Variables.System.CollectionId, "7aee6dde-6381-4098-93e7-50a8264cf066");
executionContext.Object.Variables.Set(Constants.Variables.System.DefinitionId, "7");
var endpoint = new ServiceEndpoint
{
Url = new Uri("http://contoso:8080/tfs/DefaultCollection/gitTest/_git/gitTest"),
};
var sourceProvider = new ConcreteSourceProvider();
sourceProvider.Initialize(tc);
// Act.
string hashKey = sourceProvider.GetBuildDirectoryHashKey(executionContext.Object, endpoint);
// Assert.
Assert.Equal("5c5c3d7ac33cca6604736eb3af977f23f1cf1146", hashKey);
}
}
public static CheckAuthRequest Create(OpenIdRelyingParty relyingParty, ServiceEndpoint provider, IDictionary<string, string> query)
{
if (relyingParty == null) throw new ArgumentNullException("relyingParty");
Protocol protocol = provider.Protocol;
string signed = query[protocol.openid.signed];
if (signed == null)
// #XXX: oidutil.log('No signature present; checkAuth aborted')
return null;
// Arguments that are always passed to the server and not
// included in the signature.
string[] whitelist = new string[] { protocol.openidnp.assoc_handle, protocol.openidnp.sig, protocol.openidnp.signed, protocol.openidnp.invalidate_handle };
string[] splitted = signed.Split(',');
// combine the previous 2 arrays (whitelist + splitted) into a new array: signed_array
string[] signed_array = new string[whitelist.Length + splitted.Length];
Array.Copy(whitelist, signed_array, whitelist.Length);
Array.Copy(splitted, 0, signed_array, whitelist.Length, splitted.Length);
var check_args = new Dictionary<string, string>();
foreach (string key in query.Keys) {
if (key.StartsWith(protocol.openid.Prefix, StringComparison.OrdinalIgnoreCase)
&& Array.IndexOf(signed_array, key.Substring(protocol.openid.Prefix.Length)) > -1)
check_args[key] = query[key];
}
check_args[protocol.openid.mode] = protocol.Args.Mode.check_authentication;
return new CheckAuthRequest(relyingParty, provider, check_args);
}
public override string GetLocalPath(IExecutionContext executionContext, ServiceEndpoint endpoint, string path)
{
Trace.Verbose("Entering SvnSourceProvider.GetLocalPath");
ISvnCommandManager svn = HostContext.CreateService<ISvnCommandManager>();
svn.Init(executionContext, endpoint, CancellationToken.None);
// We assume that this is a server path first.
string serverPath = svn.NormalizeRelativePath(path, '/', '\\').Trim();
string localPath;
if (serverPath.StartsWith("^/"))
{
//Convert the server path to the relative one using SVN work copy mappings
string sourcesDirectory = executionContext.Variables.Build_SourcesDirectory;
localPath = svn.ResolveServerPath(serverPath, sourcesDirectory);
}
else
{
// normalize the path back to the local file system one.
localPath = svn.NormalizeRelativePath(serverPath, Path.DirectorySeparatorChar, '/');
}
Trace.Verbose("Leaving SvnSourceProvider.GetLocalPath");
return localPath;
}
public static VssCredentials GetVssCredential(ServiceEndpoint serviceEndpoint)
{
ArgUtil.NotNull(serviceEndpoint, nameof(serviceEndpoint));
ArgUtil.NotNull(serviceEndpoint.Authorization, nameof(serviceEndpoint.Authorization));
ArgUtil.NotNullOrEmpty(serviceEndpoint.Authorization.Scheme, nameof(serviceEndpoint.Authorization.Scheme));
if (serviceEndpoint.Authorization.Parameters.Count == 0)
{
throw new ArgumentOutOfRangeException(nameof(serviceEndpoint));
}
VssCredentials credentials = null;
string accessToken;
if (serviceEndpoint.Authorization.Scheme == EndpointAuthorizationSchemes.OAuth &&
serviceEndpoint.Authorization.Parameters.TryGetValue(EndpointAuthorizationParameters.AccessToken, out accessToken))
{
//TODO: consume the new Microsoft.VisualStudio.Services.OAuth.VssOAuthAccessTokenCredential
//when it is available in the rest SDK
#pragma warning disable 618
credentials = new VssOAuthCredential(accessToken);
#pragma warning restore 618
}
return credentials;
}
protected virtual void OnSending(ServiceEndpoint provider, IDictionary<string, string> fields)
{
var sending = Sending;
if (sending != null) {
sending(provider, fields);
}
}
public async Task GetSourceAsync(IExecutionContext executionContext, ServiceEndpoint endpoint, CancellationToken cancellationToken)
{
Trace.Verbose("Entering SvnSourceProvider.GetSourceAsync");
// Validate args.
ArgUtil.NotNull(executionContext, nameof(executionContext));
ArgUtil.NotNull(endpoint, nameof(endpoint));
ISvnCommandManager svn = HostContext.CreateService<ISvnCommandManager>();
svn.Init(executionContext, endpoint, cancellationToken);
// Determine the sources directory.
string sourcesDirectory = executionContext.Variables.Build_SourcesDirectory;
executionContext.Debug($"sourcesDirectory={sourcesDirectory}");
ArgUtil.NotNullOrEmpty(sourcesDirectory, nameof(sourcesDirectory));
string sourceBranch = executionContext.Variables.Build_SourceBranch;
executionContext.Debug($"sourceBranch={sourceBranch}");
string revision = executionContext.Variables.Build_SourceVersion;
if (string.IsNullOrWhiteSpace(revision))
{
revision = "HEAD";
}
executionContext.Debug($"revision={revision}");
bool clean = endpoint.Data.ContainsKey(WellKnownEndpointData.Clean) &&
StringUtil.ConvertToBoolean(endpoint.Data[WellKnownEndpointData.Clean], defaultValue: false);
executionContext.Debug($"clean={clean}");
// Get the definition mappings.
List<SvnMappingDetails> allMappings = JsonConvert.DeserializeObject<SvnWorkspace>(endpoint.Data[WellKnownEndpointData.SvnWorkspaceMapping]).Mappings;
if (executionContext.Variables.System_Debug.HasValue && executionContext.Variables.System_Debug.Value)
{
allMappings.ForEach(m => executionContext.Debug($"ServerPath: {m.ServerPath}, LocalPath: {m.LocalPath}, Depth: {m.Depth}, Revision: {m.Revision}, IgnoreExternals: {m.IgnoreExternals}"));
}
Dictionary<string, SvnMappingDetails> normalizedMappings = svn.NormalizeMappings(allMappings);
if (executionContext.Variables.System_Debug.HasValue && executionContext.Variables.System_Debug.Value)
{
executionContext.Debug($"Normalized mappings count: {normalizedMappings.Count}");
normalizedMappings.ToList().ForEach(p => executionContext.Debug($" [{p.Key}] ServerPath: {p.Value.ServerPath}, LocalPath: {p.Value.LocalPath}, Depth: {p.Value.Depth}, Revision: {p.Value.Revision}, IgnoreExternals: {p.Value.IgnoreExternals}"));
}
string normalizedBranch = svn.NormalizeRelativePath(sourceBranch, '/', '\\');
executionContext.Output(StringUtil.Loc("SvnSyncingRepo", endpoint.Name));
string effectiveRevision = await svn.UpdateWorkspace(
sourcesDirectory,
normalizedMappings,
clean,
normalizedBranch,
revision);
executionContext.Output(StringUtil.Loc("SvnBranchCheckedOut", normalizedBranch, endpoint.Name, effectiveRevision));
Trace.Verbose("Leaving SvnSourceProvider.GetSourceAsync");
}
public IDictionary<string, string> SendDirectMessageAndGetResponse(ServiceEndpoint providerEndpoint, IDictionary<string, string> fields) {
OpenIdProvider provider = new OpenIdProvider(providerStore, providerEndpoint.ProviderEndpoint,
providerEndpoint.ProviderEndpoint, fields.ToNameValueCollection());
Debug.Assert(provider.Request.IsResponseReady, "Direct messages should always have an immediately available response.");
Response webResponse = (Response)provider.Request.Response;
EncodableResponse opAuthResponse = (EncodableResponse)webResponse.EncodableMessage;
return opAuthResponse.EncodedFields;
}
public void WithPort_Valid()
{
var before = new ServiceEndpoint("host", 10);
var after = before.WithPort(20);
Assert.Equal(before.Host, after.Host);
Assert.Equal(10, before.Port);
Assert.Equal(20, after.Port);
}
public void Init()
{
fixture = new Fixture();
spanCollectorBuilder = MockRepository.GenerateStub<ISpanCollectorBuilder>();
zipkinEndpoint = MockRepository.GenerateStub<ServiceEndpoint>();
traceProvider = MockRepository.GenerateStub<ITraceProvider>();
logger = MockRepository.GenerateStub<IMDLogger>();
requestName = fixture.Create<string>();
}
public void WithHost_Valid()
{
var before = new ServiceEndpoint("before", 10);
var after = before.WithHost("after");
Assert.Equal(before.Port, after.Port);
Assert.Equal("before", before.Host);
Assert.Equal("after", after.Host);
}
internal static void RegisterMockXrdsResponse(ServiceEndpoint endpoint) {
if (endpoint == null) throw new ArgumentNullException("endpoint");
string identityUri;
if (endpoint.ClaimedIdentifier == endpoint.Protocol.ClaimedIdentifierForOPIdentifier) {
identityUri = endpoint.UserSuppliedIdentifier;
} else {
identityUri = endpoint.UserSuppliedIdentifier ?? endpoint.ClaimedIdentifier;
}
RegisterMockXrdsResponse(new Uri(identityUri), new ServiceEndpoint[] { endpoint });
}
internal ChannelEndpointElement WriteChannelDescription(ServiceEndpoint endpoint, string typeName)
{
ChannelEndpointElement element = null;
BindingDictionaryValue value2 = this.CreateBindingConfig(endpoint.Binding);
element = new ChannelEndpointElement(endpoint.Address, typeName);
element.Name = NamingHelper.GetUniqueName(NamingHelper.CodeName(endpoint.Name), new NamingHelper.DoesNameExist(this.CheckIfChannelNameInUse), null);
element.BindingConfiguration = value2.BindingName;
element.Binding = value2.BindingSectionName;
this.channels.Add(element);
return element;
}
protected DirectRequest(OpenIdRelyingParty relyingParty, ServiceEndpoint provider, IDictionary<string, string> args) {
if (relyingParty == null) throw new ArgumentNullException("relyingParty");
if (provider == null) throw new ArgumentNullException("provider");
if (args == null) throw new ArgumentNullException("args");
RelyingParty = relyingParty;
Provider = provider;
Args = args;
if (Protocol.QueryDeclaredNamespaceVersion != null &&
!Args.ContainsKey(Protocol.openid.ns))
Args.Add(Protocol.openid.ns, Protocol.QueryDeclaredNamespaceVersion);
}
public void GetEndpoint()
{
var serviceName = fixture.Create<string>();
var zipkinEndpoint = new ServiceEndpoint();
var endpoint = zipkinEndpoint.GetEndpoint(serviceName);
Assert.IsNotNull(endpoint);
Assert.AreEqual(serviceName, endpoint.Service_name);
Assert.IsNotNull(endpoint.Ipv4);
Assert.IsNotNull(endpoint.Port);
}
public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
{
foreach (ClientOperation clientOperation in clientRuntime.ClientOperations)
{
if (clientOperation.Name == "TestFaultWithKnownType")
{
testFaultWithKnownTypeClientOp = clientOperation;
return;
}
}
throw new Exception("Expected TestFaultWithKnownType in the ClientOperations, Actual: TestFaultWithKnownType NOT Found");
}
/// <summary>
/// Initializes a new instance of the <see cref="AuthenticationRequest"/> class.
/// </summary>
/// <param name="endpoint">The endpoint that describes the OpenID Identifier and Provider that will complete the authentication.</param>
/// <param name="realm">The realm, or root URL, of the host web site.</param>
/// <param name="returnToUrl">The base return_to URL that the Provider should return the user to to complete authentication. This should not include callback parameters as these should be added using the <see cref="AddCallbackArguments(string, string)"/> method.</param>
/// <param name="relyingParty">The relying party that created this instance.</param>
private AuthenticationRequest(ServiceEndpoint endpoint, Realm realm, Uri returnToUrl, OpenIdRelyingParty relyingParty)
{
ErrorUtilities.VerifyArgumentNotNull(endpoint, "endpoint");
ErrorUtilities.VerifyArgumentNotNull(realm, "realm");
ErrorUtilities.VerifyArgumentNotNull(returnToUrl, "returnToUrl");
ErrorUtilities.VerifyArgumentNotNull(relyingParty, "relyingParty");
this.endpoint = endpoint;
this.RelyingParty = relyingParty;
this.Realm = realm;
this.ReturnToUrl = returnToUrl;
this.Mode = AuthenticationRequestMode.Setup;
}
public static AssociateRequest Create(OpenIdRelyingParty relyingParty, ServiceEndpoint provider, string assoc_type, string session_type, bool allowNoSession)
{
if (relyingParty == null) throw new ArgumentNullException("relyingParty");
if (provider == null) throw new ArgumentNullException("provider");
if (assoc_type == null) throw new ArgumentNullException("assoc_type");
if (session_type == null) throw new ArgumentNullException("session_type");
Debug.Assert(Array.IndexOf(provider.Protocol.Args.SignatureAlgorithm.All, assoc_type) >= 0);
Debug.Assert(Array.IndexOf(provider.Protocol.Args.SessionType.All, session_type) >= 0);
if (!HmacShaAssociation.IsDHSessionCompatible(provider.Protocol, assoc_type, session_type)) {
throw new OpenIdException(string.Format(CultureInfo.CurrentCulture,
Strings.IncompatibleAssociationAndSessionTypes, assoc_type, session_type));
}
var args = new Dictionary<string, string>();
Protocol protocol = provider.Protocol;
args.Add(protocol.openid.mode, protocol.Args.Mode.associate);
args.Add(protocol.openid.assoc_type, assoc_type);
DiffieHellman dh = null;
if (provider.ProviderEndpoint.Scheme == Uri.UriSchemeHttps && allowNoSession) {
Logger.InfoFormat("Requesting association with {0} (assoc_type = '{1}', session_type = '{2}').",
provider.ProviderEndpoint, assoc_type, protocol.Args.SessionType.NoEncryption);
args.Add(protocol.openid.session_type, protocol.Args.SessionType.NoEncryption);
} else {
Logger.InfoFormat("Requesting association with {0} (assoc_type = '{1}', session_type = '{2}').",
provider.ProviderEndpoint, assoc_type, session_type);
// Initiate Diffie-Hellman Exchange
dh = DiffieHellmanUtil.CreateDiffieHellman();
byte[] dhPublic = dh.CreateKeyExchange();
string cpub = DiffieHellmanUtil.UnsignedToBase64(dhPublic);
args.Add(protocol.openid.session_type, session_type);
args.Add(protocol.openid.dh_consumer_public, cpub);
DHParameters dhps = dh.ExportParameters(true);
if (dhps.P != DiffieHellmanUtil.DEFAULT_MOD || dhps.G != DiffieHellmanUtil.DEFAULT_GEN) {
args.Add(protocol.openid.dh_modulus, DiffieHellmanUtil.UnsignedToBase64(dhps.P));
args.Add(protocol.openid.dh_gen, DiffieHellmanUtil.UnsignedToBase64(dhps.G));
}
}
return new AssociateRequest(relyingParty, provider, args, dh);
}
public static AssociateRequest Create(OpenIdRelyingParty relyingParty, ServiceEndpoint provider) {
if (relyingParty == null) throw new ArgumentNullException("relyingParty");
if (provider == null) throw new ArgumentNullException("provider");
string assoc_type, session_type;
if (HmacShaAssociation.TryFindBestAssociation(provider.Protocol,
relyingParty.Settings.MinimumHashBitLength, relyingParty.Settings.MaximumHashBitLength,
true, out assoc_type, out session_type)) {
return Create(relyingParty, provider, assoc_type, session_type, true);
} else {
// There are no associations that meet all requirements.
Logger.Warn("Security requirements and protocol combination knock out all possible association types. Dumb mode forced.");
return null;
}
}
public void ShouldDisposeSourcesAndPublishers()
{
IMessageSource<IRequest> requestSource = A.Fake<IMessageSource<IRequest>>();
IMessageSource<ICommand> commandSource = A.Fake<IMessageSource<ICommand>>();
IMessagePublisher<IEvent> eventPublisher = A.Fake<IMessagePublisher<IEvent>>();
IMessagePublisher<IResponse> responsePublisher = A.Fake<IMessagePublisher<IResponse>>();
IServiceEndpoint endpoint = new ServiceEndpoint(requestSource, commandSource, eventPublisher, responsePublisher, typeof(ITestServiceMessage1));
endpoint.Dispose();
A.CallTo(() => requestSource.Dispose()).MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => commandSource.Dispose()).MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => eventPublisher.Dispose()).MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => responsePublisher.Dispose()).MustHaveHappened(Repeated.Exactly.Once);
}
public TrackingConfig(IExecutionContext executionContext, ServiceEndpoint endpoint, int buildDirectory, string hashKey)
{
// Set the directories.
BuildDirectory = buildDirectory.ToString(CultureInfo.InvariantCulture);
ArtifactsDirectory = Path.Combine(BuildDirectory, Constants.Build.Path.ArtifactsDirectory);
SourcesDirectory = Path.Combine(BuildDirectory, Constants.Build.Path.SourcesDirectory);
TestResultsDirectory = Path.Combine(BuildDirectory, Constants.Build.Path.TestResultsDirectory);
// Set the other properties.
CollectionId = executionContext.Variables.System_CollectionId;
DefinitionId = executionContext.Variables.System_DefinitionId;
HashKey = hashKey;
RepositoryUrl = endpoint.Url.AbsoluteUri;
System = BuildSystem;
UpdateJobRunProperties(executionContext);
}
AuthenticationRequest(ServiceEndpoint endpoint,
Realm realm, Uri returnToUrl, OpenIdRelyingParty relyingParty) {
if (endpoint == null) throw new ArgumentNullException("endpoint");
if (realm == null) throw new ArgumentNullException("realm");
if (returnToUrl == null) throw new ArgumentNullException("returnToUrl");
if (relyingParty == null) throw new ArgumentNullException("relyingParty");
this.endpoint = endpoint;
RelyingParty = relyingParty;
Realm = realm;
ReturnToUrl = returnToUrl;
Mode = AuthenticationRequestMode.Setup;
OutgoingExtensions = ExtensionArgumentsManager.CreateOutgoingExtensions(endpoint.Protocol);
ReturnToArgs = new Dictionary<string, string>();
}
public void ApplyClientBehavior (ServiceEndpoint endpoint, ClientRuntime clientRuntime)
{
ClientBehaviorApplied = true;
var inspector = new MessageInspector ();
inspector.RequestSending += delegate (ref Message message, IClientChannel channel) {
if (RequestSending != null)
return RequestSending (ref message, channel);
else
return null;
};
inspector.ReplyReceived += delegate (ref Message reply, object correlationState) {
if (ReplyReceived != null)
ReplyReceived (ref reply, correlationState);
};
clientRuntime.MessageInspectors.Add (inspector);
}
public void ApplyDispatchBehavior (ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
{
DispatchBehaviorApplied = true;
var inspector = new DispatchMessageInspector ();
inspector.RequestReceived += delegate (ref Message message, IClientChannel channel, InstanceContext instanceContext) {
if (RequestReceived != null)
return RequestReceived (ref message, channel, instanceContext);
else
return null;
};
inspector.ReplySending += delegate (ref Message reply, object correlationState) {
if (ReplySending != null)
ReplySending (ref reply, correlationState);
};
endpointDispatcher.DispatchRuntime.MessageInspectors.Add (inspector);
}
public void Init(
IExecutionContext context,
ServiceEndpoint endpoint,
CancellationToken cancellationToken)
{
// Validation.
ArgUtil.NotNull(context, nameof(context));
ArgUtil.NotNull(endpoint, nameof(endpoint));
ArgUtil.NotNull(cancellationToken, nameof(cancellationToken));
ArgUtil.NotNull(endpoint.Url, nameof(endpoint.Url));
ArgUtil.Equal(true, endpoint.Url.IsAbsoluteUri, nameof(endpoint.Url.IsAbsoluteUri));
ArgUtil.NotNull(endpoint.Data, nameof(endpoint.Data));
ArgUtil.NotNull(endpoint.Authorization, nameof(endpoint.Authorization));
ArgUtil.NotNull(endpoint.Authorization.Parameters, nameof(endpoint.Authorization.Parameters));
ArgUtil.Equal(EndpointAuthorizationSchemes.UsernamePassword, endpoint.Authorization.Scheme, nameof(endpoint.Authorization.Scheme));
_context = context;
_endpoint = endpoint;
_cancellationToken = cancellationToken;
// Find svn in %Path%
IWhichUtil whichTool = HostContext.GetService<IWhichUtil>();
string svnPath = whichTool.Which("svn");
if (string.IsNullOrEmpty(svnPath))
{
throw new Exception(StringUtil.Loc("SvnNotInstalled"));
}
else
{
_context.Debug($"Found svn installation path: {svnPath}.");
_svn = svnPath;
}
// External providers may need basic auth or tokens
endpoint.Authorization.Parameters.TryGetValue(EndpointAuthorizationParameters.Username, out _username);
endpoint.Authorization.Parameters.TryGetValue(EndpointAuthorizationParameters.Password, out _password);
// TODO: replace explicit string literals with WellKnownEndpointData constants
// as soon as the latters are available thru the Microsoft.TeamFoundation.Build.WebApi package
_acceptUntrusted = endpoint.Data.ContainsKey(/* WellKnownEndpointData.SvnAcceptUntrustedCertificates */ "acceptUntrustedCerts") &&
StringUtil.ConvertToBoolean(endpoint.Data[/* WellKnownEndpointData.SvnAcceptUntrustedCertificates */ "acceptUntrustedCerts"], defaultValue: false);
}
public IDictionary<string, string> SendDirectMessageAndGetResponse(ServiceEndpoint provider, IDictionary<string, string> fields)
{
if (provider == null) throw new ArgumentNullException("provider");
if (fields == null) throw new ArgumentNullException("fields");
byte[] body = ProtocolMessages.Http.GetBytes(fields);
IDictionary<string, string> args;
UntrustedWebResponse resp = null;
string fullResponseText = null;
try {
resp = UntrustedWebRequest.Request(provider.ProviderEndpoint, body);
// If an internal server error occurred, there won't be any KV-form stream
// to read in. So instead, preserve whatever error the server did send back
// and throw it in the exception.
if (resp.StatusCode == HttpStatusCode.InternalServerError) {
string errorStream = new StreamReader(resp.ResponseStream).ReadToEnd();
throw new OpenIdException(string.Format(CultureInfo.CurrentCulture,
Strings.ProviderRespondedWithError, errorStream));
}
if (Logger.IsDebugEnabled) {
fullResponseText = resp.ReadResponseString();
}
args = ProtocolMessages.KeyValueForm.GetDictionary(resp.ResponseStream);
Logger.DebugFormat("Received direct response from {0}: {1}{2}", provider.ProviderEndpoint,
Environment.NewLine, Util.ToString(args));
} catch (ArgumentException e) {
Logger.DebugFormat("Full response from provider (where KVF was expected):{0}{1}",
Environment.NewLine, fullResponseText);
throw new OpenIdException("Failure decoding Key-Value Form response from provider.", e);
} catch (WebException e) {
throw new OpenIdException("Failure while connecting to provider.", e);
}
// All error codes are supposed to be returned with 400, but
// some (like myopenid.com) sometimes send errors as 200's.
if (resp.StatusCode == HttpStatusCode.BadRequest ||
Util.GetOptionalArg(args, provider.Protocol.openidnp.mode) == provider.Protocol.Args.Mode.error) {
throw new OpenIdException(string.Format(CultureInfo.CurrentCulture,
Strings.ProviderRespondedWithError,
Util.GetOptionalArg(args, provider.Protocol.openidnp.error)), args);
} else if (resp.StatusCode == HttpStatusCode.OK) {
return args;
} else {
throw new OpenIdException(string.Format(CultureInfo.CurrentCulture,
Strings.ProviderRespondedWithUnrecognizedHTTPStatusCode, resp.StatusCode));
}
}
AuthenticationRequest(string token, Association assoc, ServiceEndpoint endpoint,
Realm realm, Uri returnToUrl, OpenIdRelyingParty relyingParty)
{
if (endpoint == null) throw new ArgumentNullException("endpoint");
if (realm == null) throw new ArgumentNullException("realm");
if (returnToUrl == null) throw new ArgumentNullException("returnToUrl");
if (relyingParty == null) throw new ArgumentNullException("relyingParty");
this.assoc = assoc;
this.endpoint = endpoint;
RelyingParty = relyingParty;
Realm = realm;
ReturnToUrl = returnToUrl;
Mode = AuthenticationRequestMode.Setup;
OutgoingExtensions = ExtensionArgumentsManager.CreateOutgoingExtensions(endpoint.Protocol);
ReturnToArgs = new Dictionary<string, string>();
if (token != null)
AddCallbackArguments(DotNetOpenId.RelyingParty.Token.TokenKey, token);
}
protected override void OnApplyConfiguration(ServiceEndpoint endpoint, ServiceEndpointElement serviceEndpointElement)
{
}
public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
{
}
public void AddECSContainerSupport_configuration_throws_if_endpoint_has_no_address(ServiceCollection services, IConfiguration configuration, ServiceEndpoint endpoint)
{
AddFakeContainerMetadataFileKey();
ECSMetadataExtensions.AddECSContainerSupport(services, configuration);
var serviceProvider = services.BuildServiceProvider();
var options = serviceProvider.GetRequiredService <IOptions <AnnouncementServiceOptions> >();
Assert.Throws <ArgumentNullException>(() => options.Value.EndpointDiscoveryMetadata(endpoint));
}
public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
{
// Set AddressFilter to CultureHeaderFilter
endpointDispatcher.AddressFilter =
new CultureHeaderFilter();
}
public void SetEndpointAddress(ServiceEndpoint endpoint, string relativeAddress)
{
throw new PlatformNotSupportedException();
}
public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
{
clientRuntime.ClientMessageInspectors.Add(new JwtHeaderMessageInspector(_options, _userToken));
}
public void ApplyClientBehavior(ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.ClientRuntime clientRuntime)
{
AutoPoolInspector <T> inspector = new AutoPoolInspector <T>(client);
clientRuntime.MessageInspectors.Add(inspector);
}
public void Validate(ServiceEndpoint endpoint)
{
}
private void AddPreflightOperations(ServiceEndpoint endpoint, List <OperationDescription> corsOperations)
{
Dictionary <string, PreflightOperationBehavior> uriTemplates = new Dictionary <string, PreflightOperationBehavior>(StringComparer.OrdinalIgnoreCase);
foreach (var operation in corsOperations)
{
if (operation.Behaviors.Find <WebGetAttribute>() != null)
{
// no need to add preflight operation for GET requests
continue;
}
if (operation.IsOneWay)
{
// no support for 1-way messages
continue;
}
string originalUriTemplate;
WebInvokeAttribute originalWia = operation.Behaviors.Find <WebInvokeAttribute>();
if (originalWia != null && originalWia.UriTemplate != null)
{
originalUriTemplate = NormalizeTemplate(originalWia.UriTemplate);
}
else
{
originalUriTemplate = operation.Name;
}
string originalMethod = originalWia != null && originalWia.Method != null ? originalWia.Method : "POST";
if (uriTemplates.ContainsKey(originalUriTemplate))
{
// there is already an OPTIONS operation for this URI, we can reuse it
PreflightOperationBehavior operationBehavior = uriTemplates[originalUriTemplate];
operationBehavior.AddAllowedMethod(originalMethod);
}
else
{
ContractDescription contract = operation.DeclaringContract;
OperationDescription preflightOperation = new OperationDescription(operation.Name + CorsConstants.PreflightSuffix, contract);
MessageDescription inputMessage = new MessageDescription(operation.Messages[0].Action + CorsConstants.PreflightSuffix, MessageDirection.Input);
inputMessage.Body.Parts.Add(new MessagePartDescription("input", contract.Namespace)
{
Index = 0, Type = typeof(Message)
});
preflightOperation.Messages.Add(inputMessage);
MessageDescription outputMessage = new MessageDescription(operation.Messages[1].Action + CorsConstants.PreflightSuffix, MessageDirection.Output);
outputMessage.Body.ReturnValue = new MessagePartDescription(preflightOperation.Name + "Return", contract.Namespace)
{
Type = typeof(Message)
};
preflightOperation.Messages.Add(outputMessage);
WebInvokeAttribute wia = new WebInvokeAttribute();
wia.UriTemplate = originalUriTemplate;
wia.Method = "OPTIONS";
preflightOperation.Behaviors.Add(wia);
preflightOperation.Behaviors.Add(new DataContractSerializerOperationBehavior(preflightOperation));
PreflightOperationBehavior preflightOperationBehavior = new PreflightOperationBehavior(preflightOperation);
preflightOperationBehavior.AddAllowedMethod(originalMethod);
preflightOperation.Behaviors.Add(preflightOperationBehavior);
uriTemplates.Add(originalUriTemplate, preflightOperationBehavior);
contract.Operations.Add(preflightOperation);
}
}
}
public void ApplyClientBehavior(ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.ClientRuntime clientRuntime)
{
OAuth2HeaderInspector inspector = new OAuth2HeaderInspector();
clientRuntime.MessageInspectors.Add(inspector);
}
public void ApplyDispatchBehavior(ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.EndpointDispatcher endpointDispatcher)
{
}
public void AddBindingParameters(ServiceEndpoint endpoint, System.ServiceModel.Channels.BindingParameterCollection bindingParameters)
{
}
public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
{
}
public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
{
clientRuntime.MessageInspectors.Add(this);
}
public void Validate(ServiceEndpoint endpoint)
{
// for future use
}
public void ApplyClientBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.ClientRuntime clientRuntime)
{
}
public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
{
// for future use
}
public void Execute(IExecutionContext context, Command command)
{
ArgUtil.NotNull(context, nameof(context));
ArgUtil.NotNull(context.Endpoints, nameof(context.Endpoints));
ArgUtil.NotNull(command, nameof(command));
var eventProperties = command.Properties;
var data = command.Data;
ServiceEndpoint systemConnection = context.Endpoints.FirstOrDefault(e => string.Equals(e.Name, WellKnownServiceEndpointNames.SystemVssConnection, StringComparison.OrdinalIgnoreCase));
ArgUtil.NotNull(systemConnection, nameof(systemConnection));
ArgUtil.NotNull(systemConnection.Url, nameof(systemConnection.Url));
Uri projectUrl = systemConnection.Url;
VssCredentials projectCredential = VssUtil.GetVssCredential(systemConnection);
Guid projectId = context.Variables.System_TeamProjectId ?? Guid.Empty;
ArgUtil.NotEmpty(projectId, nameof(projectId));
int?buildId = context.Variables.Build_BuildId;
ArgUtil.NotNull(buildId, nameof(buildId));
string artifactName;
if (!eventProperties.TryGetValue(ArtifactAssociateEventProperties.ArtifactName, out artifactName) ||
string.IsNullOrEmpty(artifactName))
{
throw new Exception(StringUtil.Loc("ArtifactNameRequired"));
}
string artifactType;
if (!eventProperties.TryGetValue(ArtifactAssociateEventProperties.ArtifactType, out artifactType))
{
artifactType = ArtifactCommandExtensionUtil.InferArtifactResourceType(context, data);
}
if (string.IsNullOrEmpty(artifactType))
{
throw new Exception(StringUtil.Loc("ArtifactTypeRequired"));
}
else if ((artifactType.Equals(ArtifactResourceTypes.Container, StringComparison.OrdinalIgnoreCase) ||
artifactType.Equals(ArtifactResourceTypes.FilePath, StringComparison.OrdinalIgnoreCase) ||
artifactType.Equals(ArtifactResourceTypes.VersionControl, StringComparison.OrdinalIgnoreCase)) &&
string.IsNullOrEmpty(data))
{
throw new Exception(StringUtil.Loc("ArtifactLocationRequired"));
}
if (!artifactType.Equals(ArtifactResourceTypes.FilePath, StringComparison.OrdinalIgnoreCase) &&
context.Variables.System_HostType != HostTypes.Build)
{
throw new Exception(StringUtil.Loc("AssociateArtifactCommandNotSupported", context.Variables.System_HostType));
}
var propertyDictionary = ArtifactCommandExtensionUtil.ExtractArtifactProperties(eventProperties);
string artifactData = "";
if (ArtifactCommandExtensionUtil.IsContainerPath(data) ||
ArtifactCommandExtensionUtil.IsValidServerPath(data))
{
//if data is a file container path or a tfvc server path
artifactData = data;
}
else if (ArtifactCommandExtensionUtil.IsUncSharePath(context, data))
{
//if data is a UNC share path
artifactData = new Uri(data).LocalPath;
}
else
{
artifactData = data ?? string.Empty;
}
// queue async command task to associate artifact.
context.Debug($"Associate artifact: {artifactName} with build: {buildId.Value} at backend.");
var commandContext = context.GetHostContext().CreateService <IAsyncCommandContext>();
commandContext.InitializeCommandContext(context, StringUtil.Loc("AssociateArtifact"));
commandContext.Task = ArtifactCommandExtensionUtil.AssociateArtifactAsync(commandContext,
WorkerUtilities.GetVssConnection(context),
projectId,
buildId.Value,
artifactName,
context.Variables.System_JobId,
artifactType,
artifactData,
propertyDictionary,
context.CancellationToken);
context.AsyncCommands.Add(commandContext);
}
public Factory(ServiceEndpoint endpoint) : base(endpoint)
{
}
public virtual void AddServiceEndpoint(ServiceEndpoint endpoint)
{
throw new PlatformNotSupportedException();
}
public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
{}
public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
{
endpointDispatcher.DispatchRuntime.InstanceContextInitializers.Add(this);
}
/// <summary>
/// Create a new service client instance of the <typeparamref name="TContract"/> using the specified <see cref="T:System.ServiceModel.InstanceContext"/> and <see cref="T:System.ServiceModel.Description.ServiceEndpoint"/> objects.
/// </summary>
/// <param name="callbackInstance">The callback object that the client application uses to listen for messages from the connected service.</param>
/// <param name="endpoint">The endpoint for a service that allows clients to find and communicate with the service.</param>
public static TContract GetService <TContract>(InstanceContext callbackInstance, ServiceEndpoint endpoint)
{
var serviceType = GetServiceType(typeof(TContract));
if (serviceType == null)
{
return(default(TContract));
}
return((TContract)Activator.CreateInstance(serviceType, callbackInstance, endpoint));
}
public void AddBindingParameters(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Channels.BindingParameterCollection bindingParameters)
{
}
public void AddECSContainerSupport_configuration_returns_metadata_with_same_if_no_mapping(ServiceCollection services, [Frozen] ECSContainerMetadata containerMetadata, IConfiguration configuration, ServiceEndpoint endpoint, int port, string address)
{
AddFakeContainerMetadataFileKey();
var expectedAddress = new Uri($"http://{containerMetadata.HostPrivateIPv4Address}:{port}/{address}");
endpoint.Address = new EndpointAddress($"http://localhost:{port}/{address}");
ECSMetadataExtensions.AddECSContainerSupport(services, configuration);
var serviceProvider = services.BuildServiceProvider();
var options = serviceProvider.GetRequiredService <IOptions <AnnouncementServiceOptions> >();
var result = options.Value.EndpointDiscoveryMetadata(endpoint);
Assert.That(result.Address.Uri, Is.EqualTo(expectedAddress).IgnoreCase);
}
public void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.DispatchRuntime dispatchRuntime)
{
}
protected override void OnApplyConfiguration(ServiceEndpoint endpoint, ServiceEndpointElement serviceEndpointElement)
{
throw new NotImplementedException();
}
public void AddECSContainerSupport_configuration_returns_metadata_with_same_address_when_ecs_metadata_has_no_ipv4_address(ServiceCollection services, IConfiguration configuration, ServiceEndpoint endpoint, int port, string address)
{
AddFakeContainerMetadataFileKey();
configuration[nameof(ECSContainerMetadata.HostPrivateIPv4Address)] = null;
endpoint.Address = new EndpointAddress($"http://localhost:{port}/{address}");
ECSMetadataExtensions.AddECSContainerSupport(services, configuration);
var serviceProvider = services.BuildServiceProvider();
var options = serviceProvider.GetRequiredService <IOptions <AnnouncementServiceOptions> >();
var result = options.Value.EndpointDiscoveryMetadata(endpoint);
Assert.That(result.Address.Uri, Is.EqualTo(endpoint.Address.Uri));
}
public void Validate(ContractDescription contractDescription, ServiceEndpoint endpoint)
{
}
public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
{
var inspector = new NewRelicClientMessageInspector(_agent, _bindingType);
clientRuntime.ClientMessageInspectors.Add(inspector);
}
