public void DisableGuestAccess()
{
var url = _adminRemoteUri.AppendPath("_user/GUEST");
var request = new HttpRequestMessage(HttpMethod.Put, url);
var data = Manager.GetObjectMapper().WriteValueAsBytes(new Dictionary <string, object> {
{ "disabled", true }
}).ToArray();
request.Content = new ByteArrayContent(data);
_httpClient.SendAsync(request).Wait();
}
public void VerifyDocumentExists(string docId)
{
var pathToDoc = _remoteUri.AppendPath(docId);
Log.D(Tag, "Send http request to " + pathToDoc);
var httpRequestDoneSignal = new CountdownEvent(1);
Task.Factory.StartNew(() =>
{
HttpResponseMessage response;
string responseString = null;
try
{
var responseTask = _httpClient.GetAsync(pathToDoc.ToString());
response = responseTask.Result;
var statusLine = response.StatusCode;
Assert.IsTrue(statusLine == HttpStatusCode.OK);
if (statusLine == HttpStatusCode.OK)
{
var responseStringTask = response.Content.ReadAsStringAsync();
responseStringTask.Wait(TimeSpan.FromSeconds(10));
responseString = responseStringTask.Result;
Assert.IsTrue(responseString.Contains(docId));
Log.D(Tag, "result: " + responseString);
}
else
{
var statusReason = response.ReasonPhrase;
response.Dispose();
throw new IOException(statusReason);
}
}
catch (ProtocolViolationException e)
{
Assert.IsNull(e, "Got ClientProtocolException: " + e.Message);
}
catch (IOException e)
{
Assert.IsNull(e, "Got IOException: " + e.Message);
}
httpRequestDoneSignal.Signal();
});
var result = httpRequestDoneSignal.Wait(TimeSpan.FromSeconds(30));
Assert.IsTrue(result, "Could not retrieve the new doc from the sync gateway.");
}
public void WhenSegmentsIsEmpty_ThenReturnSameUri()
{
var sut = new Uri("http://local");
var result = sut.AppendPath();
Assert.That(result, Is.SameAs(sut));
}
public void WhenPathHasEndSlash_ThenAppendPath()
{
var sut = new Uri("https://example.com:8080/over/there/?name=John#myfrag");
var result = sut.AppendPath("path/path2");
Assert.That(result, Is.EqualTo(new Uri("https://example.com:8080/over/there/path/path2/?name=John#myfrag")));
}
public void WhenHasPath_ThenAppendPath(string path)
{
var sut = new Uri("https://example.com:8080/over/there?name=John#myfrag");
var result = sut.AppendPath(path);
Assert.That(result, Is.EqualTo(new Uri($"https://example.com:8080/over/there/{path}?name=John#myfrag")));
}
public void WhenPathIsNullOrEmpty_ThenReturnSameUri(string path)
{
var sut = new Uri("http://local/myapp");
var result = sut.AppendPath(path);
Assert.That(sut, Is.SameAs(result));
}
public void WhenHasNoPath_AndStartsWithSlash_ThenAppendPath(string path)
{
var sut = new Uri("http://local/");
var result = sut.AppendPath(path);
Assert.That(result, Is.EqualTo(new Uri("http://local" + path)));
}
public void WhenHasNoPath_ThenAppendPath()
{
var sut = new Uri("https://example.com:8080/?name=John#myfrag");
var result = sut.AppendPath("path1", "path2");
Assert.That(result, Is.EqualTo(new Uri("https://example.com:8080/path1/path2?name=John#myfrag")));
}
public void WhenTwoSegments_ThenAppendPath(string segment1, string segment2)
{
var sut = new Uri("https://example.com:8080/over/there?name=John#myfrag");
var result = sut.AppendPath(segment1, segment2);
Assert.That(result, Is.EqualTo(new Uri("https://example.com:8080/over/there/path1/path2?name=John#myfrag")));
}
public void WhenOneSegment_ThenAppendPath(string segment)
{
var sut = new Uri("https://example.com:8080/over/there?name=John#myfrag");
var result = sut.AppendPath(new[] { segment });
Assert.That(result, Is.EqualTo(new Uri("https://example.com:8080/over/there/path?name=John#myfrag")));
}
public void WhenHasPath_AndStartsWithSlash_ThenAppendPath(string path)
{
var sut = new Uri("https://example.com:8080/over/there?name=John#myfrag");
var result = sut.AppendPath(path);
var pathNoStartSlash = path.RemoveStartsWith("/");
Assert.That(result, Is.EqualTo(new Uri($"https://example.com:8080/over/there/{pathNoStartSlash}?name=John#myfrag")));
}
public WcfChannelProxy(Fiber fiber, Uri serviceUri, string pipeName)
{
_fiber = fiber;
Serializer = new FastTextSerializer();
ServiceUri = serviceUri;
PipeName = pipeName;
_address = new EndpointAddress(serviceUri.AppendPath(pipeName));
_proxy = System.ServiceModel.ChannelFactory <WcfChannel <WcfMessageEnvelope> > .CreateChannel(new NetNamedPipeBinding(),
_address);
}
public void Renew(Uri BaseUri, TimeSpan NewDuration)
{
try
{
var NewReservation = Utils.InvokeAPI <Reservation>(BaseUri.AppendPath("api/v1/reservations/" + Guid.ToString()), "PUT", NewDuration);
Copy(NewReservation);
}
catch (Exception ex)
{
throw new AutomationException(ex, "Failed to renew device reservation.");
}
}
public void Delete(Uri BaseUri)
{
try
{
Utils.InvokeAPI(BaseUri.AppendPath("api/v1/reservations/" + Guid.ToString()), "DELETE");
Console.WriteLine("Successfully deleted device reservation \"{0}\".", Guid);
}
catch (Exception ex)
{
Console.WriteLine("Failed to delete device reservation: {0}", ex.Message);
}
}
public void VerifyDocumentExists(string docId)
{
var pathToDoc = _remoteUri.AppendPath(docId);
LiteTestCase.WriteDebug("Send http request to " + pathToDoc);
var httpRequestDoneSignal = new CountdownEvent(1);
var t = Task.Factory.StartNew(() =>
{
HttpResponseMessage response;
string responseString = null;
var responseTask = _httpClient.GetAsync(pathToDoc.ToString());
response = responseTask.Result;
var statusLine = response.StatusCode;
try {
Assert.IsTrue(statusLine == HttpStatusCode.OK);
if (statusLine == HttpStatusCode.OK)
{
var responseStringTask = response.Content.ReadAsStringAsync();
responseStringTask.Wait(TimeSpan.FromSeconds(10));
responseString = responseStringTask.Result;
Assert.IsTrue(responseString.Contains(docId));
LiteTestCase.WriteDebug("result: {0}", responseString);
}
else
{
var statusReason = response.ReasonPhrase;
response.Dispose();
throw new IOException(statusReason);
}
} finally {
httpRequestDoneSignal.Signal();
}
});
var result = httpRequestDoneSignal.Wait(TimeSpan.FromSeconds(30));
Assert.IsTrue(result, "Could not retrieve the new doc from the sync gateway.");
Assert.IsNull(t.Exception);
}
TResponse makeStatsRequest <TResponse>(string key, Method verb) where TResponse : new()
{
var requestUrl = _root.AppendPath("v2").AppendPath("stats").AppendPath(key);
var request = new RestRequest(requestUrl, verb);
var response = _client.Execute <TResponse>(request);
if (checkForError(response))
{
throw constructException(response);
}
return(response.Data);
}
/// <summary>
/// Sets up a watch on a keyspace and will call the callback when triggered
/// </summary>
/// <param name="key">key</param>
/// <param name="followUp">callback</param>
/// <param name="recursive">watch subkeys?</param>
/// <param name="timeout">How long will we watch?</param>
/// <param name="waitIndex">Index to wait from</param>
public void Watch(string key, Action <EtcdResponse> followUp, bool recursive = false, int?timeout = null, int?waitIndex = null)
{
var requestUrl = _keysRoot.AppendPath(key);
var getRequest = new RestRequest(requestUrl, Method.GET);
getRequest.AddParameter("wait", "true");
if (recursive)
{
getRequest.AddParameter("recursive", "true");
}
if (timeout.HasValue)
{
getRequest.Timeout = timeout.Value * 1000;
}
if (waitIndex.HasValue)
{
getRequest.AddParameter("waitIndex", waitIndex);
}
_client.ExecuteAsync <EtcdResponse>(getRequest, r => followUp(processRestResponse(r)));
}
public async Task <TokenConfigurationModel> GetAsync(Uri authorityUrl, ILoggingContext context, CancellationToken cancellationToken)
{
var url = authorityUrl.AppendPath("api/v1/token/configuration");
var client = HttpClientContext.Client;
var result = await client.GetAsync(url, cancellationToken);
result.EnsureSuccessStatusCode();
var body = await result.Content.ReadAsStringAsync(cancellationToken);
var model = await JsonConvert.DeserializeAsync <TokenConfigurationModel>(body, JsonConvert.CammelCaseOptions, cancellationToken);
Debug.Assert(model != null);
return(model);
}
private static string AppendRelativeURLString(Uri remote, string relativePath)
{
var uri = remote.AppendPath(relativePath);
return(uri.AbsoluteUri);
// the following code is a band-aid for a system problem in the codebase
// where it is appending "relative paths" that start with a slash, eg:
// http://dotcom/db/ + /relpart == http://dotcom/db/relpart
// which is not compatible with the way the java url concatonation works.
// var remoteUrlString = remote.AbsolutePath;
// if (remoteUrlString.EndsWith ("/", StringComparison.Ordinal)
// && relativePath.StartsWith ("/", StringComparison.Ordinal))
// {
// remoteUrlString = remoteUrlString.Substring(0, remoteUrlString.Length - 1);
// }
// return remoteUrlString + relativePath;
}
TResponse makeStatsRequest <TResponse>(string key, Method verb) where TResponse : new()
{
var requestUrl = _root.AppendPath("v2").AppendPath("stats").AppendPath(key);
var request = new RestRequest(requestUrl, verb);
//needed due to issue 469 - https://github.com/coreos/etcd/issues/469
request.OnBeforeDeserialization = resp => { resp.ContentType = "application/json"; };
var response = _client.Execute <TResponse>(request);
if (checkForError(response))
{
throw constructException(response);
}
return(response.Data);
}
public static Reservation Create(Uri BaseUri, string[] DeviceTypes, TimeSpan Duration)
{
bool bFirst = true;
while (true)
{
if (!bFirst)
{
TimeSpan RetryTime = TimeSpan.FromMinutes(1);
Console.WriteLine("Retrying in {0} seconds ...", RetryTime.TotalSeconds);
Thread.Sleep(RetryTime);
}
bFirst = false;
Console.WriteLine("Requesting device reservation...");
Exception UnknownException;
try
{
return(Utils.InvokeAPI <Reservation>(BaseUri.AppendPath("api/v1/reservations"), "POST", new CreateReservationData()
{
DeviceTypes = DeviceTypes,
Hostname = Environment.MachineName,
Duration = Duration
}));
}
catch (WebException WebEx)
{
if ((WebEx.Response as HttpWebResponse).StatusCode == HttpStatusCode.Conflict)
{
Console.WriteLine("No devices currently available.");
continue; // Retry
}
UnknownException = WebEx;
}
catch (Exception Ex)
{
UnknownException = Ex;
}
Console.WriteLine("Warning: Device reservation unsuccessful: {0}", UnknownException.Message);
}
}
TResponse makeMemberRequest <TResponse>(string key = null, Method method = Method.GET, Action <IRestRequest> action = null) where TResponse : new()
{
var requestUrl = _root.AppendPath("v2").AppendPath("members");
if (!string.IsNullOrEmpty(key))
{
requestUrl = requestUrl.AppendPath(key);
}
var request = new RestRequest(requestUrl, method);
request.AddHeader("Accept", "*/*");
request.AddHeader("Accept-Encoding", "");
var response = _client.Execute <TResponse>(request);
return(response.Data);
}
static public void ReportDeviceError(string InBaseUri, string DeviceName, string Error)
{
if (String.IsNullOrEmpty(InBaseUri) || String.IsNullOrEmpty(DeviceName))
{
return;
}
try
{
Uri BaseUri = new Uri(InBaseUri);
Utils.InvokeAPI(BaseUri.AppendPath("api/v1/deviceerror/" + DeviceName), "PUT");
Console.WriteLine("Reported device problem: {0} : {1}", DeviceName, Error);
}
catch (Exception Ex)
{
Console.WriteLine("Failed to report device: {0} : {1}", DeviceName, Ex.Message);
}
}
private static Uri GetRedirectUri(Uri originalUri, HttpResponseMessage response)
{
var locationUri = response.Headers.Location;
if (locationUri == null)
{
return(null);
}
if (locationUri.IsAbsoluteUri)
{
return(locationUri);
}
if (locationUri.IsRelativeUriWithAbsolutePath())
{
return(new Uri(originalUri, locationUri));
}
return(originalUri.AppendPath(locationUri));
}
TResponse makeMachineRequest <TResponse>(string key = null) where TResponse : new()
{
var requestUrl = _root.AppendPath("v2").AppendPath("admin").AppendPath("machines");
if (!string.IsNullOrEmpty(key))
{
requestUrl = requestUrl.AppendPath(key);
}
var request = new RestRequest(requestUrl, Method.GET);
request.AddHeader("Accept", "*/*");
request.AddHeader("Accept-Encoding", "");
//needed due to issue 469 - https://github.com/coreos/etcd/issues/469
request.OnBeforeDeserialization = resp => { resp.ContentType = "application/json"; };
var response = _client.Execute <TResponse>(request);
return(response.Data);
}
public ConfigurationFreeChannelFactory(Uri serviceUri, string pipeName)
: base(new NetNamedPipeBinding(), new EndpointAddress(serviceUri.AppendPath(pipeName)))
{
}
public static Reservation Create(Uri BaseUri, string[] DeviceTypes, TimeSpan Duration, int RetryMax = 5)
{
bool bFirst = true;
TimeSpan RetryTime = TimeSpan.FromMinutes(1);
int RetryCount = 0;
while (true)
{
if (!bFirst)
{
Thread.Sleep(RetryTime);
}
bFirst = false;
Console.WriteLine("Requesting device reservation...");
Exception UnknownException;
try
{
return(Utils.InvokeAPI <Reservation>(BaseUri.AppendPath("api/v1/reservations"), "POST", new CreateReservationData()
{
DeviceTypes = DeviceTypes,
Hostname = Environment.MachineName,
Duration = Duration,
ReservationDetails = ReservationDetails
}));
}
catch (WebException WebEx)
{
Console.WriteLine(String.Format("WebException on reservation request: {0} : {1}", WebEx.Message, WebEx.Status));
if (RetryCount == RetryMax)
{
Console.WriteLine("Device reservation unsuccessful");
throw new AutomationException(WebEx, "Device reservation unsuccessful, devices unavailable");
}
string RetryMessage = String.Format("retry {0} of {1} in {2} minutes", RetryCount + 1, RetryMax, RetryTime.Minutes);
string Message = String.Format("Unknown device server error, {0}", RetryMessage);
if (WebEx.Response == null)
{
Message = String.Format("Devices service currently not available, {0}", RetryMessage);
}
else if ((WebEx.Response as HttpWebResponse).StatusCode == HttpStatusCode.Conflict)
{
Message = String.Format("No devices currently available, {0}", RetryMessage);
}
Console.WriteLine(Message);
RetryCount++;
UnknownException = WebEx;
}
catch (Exception Ex)
{
UnknownException = Ex;
string Line = UnknownException.Message;
string[] TriggersSrc = { "Warning:", "Error:", "Exception:" };
string[] TriggersDst = { "Warn1ng:", "Err0r:", "Except10n:" };
for (int Index = 0; Index < TriggersSrc.Length; ++Index)
{
if (Line.IndexOf(TriggersSrc[Index], StringComparison.OrdinalIgnoreCase) != -1)
{
Line = Regex.Replace(Line, TriggersSrc[Index], TriggersDst[Index], RegexOptions.IgnoreCase);
}
}
Console.WriteLine("Device reservation unsuccessful: {0}", Line);
}
}
}
public static Device Get(Uri BaseUri, string DeviceName)
{
return(Utils.InvokeAPI <Device>(BaseUri.AppendPath("api/v1/devices/" + DeviceName), "GET", null));
}
private static string AppendRelativeURLString(Uri remote, string relativePath)
{
var uri = remote.AppendPath(relativePath);
return(uri.AbsoluteUri);
}
public static Reservation Create(Uri BaseUri, string[] DeviceTypes, TimeSpan Duration, int RetryMax = 5, string PoolID = "")
{
bool bFirst = true;
TimeSpan RetryTime = TimeSpan.FromMinutes(1);
int RetryCount = 0;
while (true)
{
if (!bFirst)
{
Thread.Sleep(RetryTime);
}
bFirst = false;
Console.WriteLine("Requesting device reservation...");
Exception UnknownException;
try
{
return(Utils.InvokeAPI <Reservation>(BaseUri.AppendPath("api/v1/reservations"), "POST", new CreateReservationData()
{
DeviceTypes = DeviceTypes,
Hostname = Environment.MachineName,
Duration = Duration,
ReservationDetails = ReservationDetails,
PoolID = PoolID
}));
}
catch (WebException WebEx)
{
Console.WriteLine(String.Format("WebException on reservation request: {0} : {1}", SanitizeErrorMessage(WebEx.Message), WebEx.Status));
if (RetryCount == RetryMax)
{
Console.WriteLine("Device reservation unsuccessful");
throw new AutomationException(WebEx, "Device reservation unsuccessful, devices unavailable");
}
string RetryMessage = String.Format("retry {0} of {1} in {2} minutes", RetryCount + 1, RetryMax, RetryTime.Minutes);
string Message = String.Format("Unknown device server error, {0}", RetryMessage);
if (WebEx.Response == null)
{
Message = String.Format("Devices service currently not available, {0}", RetryMessage);
}
else if ((WebEx.Response as HttpWebResponse).StatusCode == HttpStatusCode.Conflict)
{
Message = String.Format("No devices currently available, {0}", RetryMessage);
}
Console.WriteLine(Message);
RetryCount++;
UnknownException = WebEx;
}
catch (Exception Ex)
{
UnknownException = Ex;
Console.WriteLine("Device reservation unsuccessful: {0}", SanitizeErrorMessage(UnknownException.Message));
}
}
}
