private void ConnectDaemon(JsonRpcRequestBuilder requestBuilder)
{
var resultConnected = ExecuteRequest <bool>(requestBuilder, "web.connected");
VerifyResponse(resultConnected);
if (resultConnected.Result)
{
return;
}
var resultHosts = ExecuteRequest <List <object[]> >(requestBuilder, "web.get_hosts");
VerifyResponse(resultHosts);
if (resultHosts.Result != null)
{
// The returned list contains the id, ip, port and status of each available connection. We want the 127.0.0.1
var connection = resultHosts.Result.FirstOrDefault(v => "127.0.0.1" == (v[1] as string));
if (connection != null)
{
var resultConnect = ExecuteRequest <object>(requestBuilder, "web.connect", new object[] { connection[0] });
VerifyResponse(resultConnect);
return;
}
}
throw new DownloadClientException("Failed to connect to Deluge daemon.");
}
private JsonRpcResponse <TResult> ExecuteRequest <TResult>(JsonRpcRequestBuilder requestBuilder, string method, params object[] arguments)
{
var request = requestBuilder.Call(method, arguments).Build();
HttpResponse response;
try
{
response = _httpClient.Execute(request);
return(Json.Deserialize <JsonRpcResponse <TResult> >(response.Content));
}
catch (HttpException ex)
{
if (ex.Response.StatusCode == HttpStatusCode.RequestTimeout)
{
_logger.Debug("Deluge timeout during request, daemon connection may have been broken. Attempting to reconnect.");
return(new JsonRpcResponse <TResult>()
{
Error = JToken.Parse("{ Code = 2 }")
});
}
else
{
throw new DownloadClientException("Unable to connect to Deluge, please check your settings", ex);
}
}
catch (WebException ex)
{
throw new DownloadClientUnavailableException("Unable to connect to Deluge, please check your settings", ex);
}
}
private void AuthenticateClient(JsonRpcRequestBuilder requestBuilder, DelugeSettings settings, bool reauthenticate = false)
{
var authKey = string.Format("{0}:{1}", requestBuilder.BaseUrl, settings.Password);
var cookies = _authCookieCache.Find(authKey);
if (cookies == null || reauthenticate)
{
_authCookieCache.Remove(authKey);
var authLoginRequest = requestBuilder.Call("auth.login", settings.Password).Build();
var response = _httpClient.Execute(authLoginRequest);
var result = Json.Deserialize <JsonRpcResponse <bool> >(response.Content);
if (!result.Result)
{
_logger.Debug("Deluge authentication failed.");
throw new DownloadClientAuthenticationException("Failed to authenticate with Deluge.");
}
_logger.Debug("Deluge authentication succeeded.");
cookies = response.GetCookies();
_authCookieCache.Set(authKey, cookies);
requestBuilder.SetCookies(cookies);
ConnectDaemon(requestBuilder);
}
else
{
requestBuilder.SetCookies(cookies);
}
}
private T ProcessRequest <T>(HadoukenSettings settings, string method, params object[] parameters)
{
var baseUrl = HttpRequestBuilder.BuildBaseUrl(settings.UseSsl, settings.Host, settings.Port, "api");
var requestBuilder = new JsonRpcRequestBuilder(baseUrl, method, parameters);
requestBuilder.LogResponseContent = true;
requestBuilder.NetworkCredential = new NetworkCredential(settings.Username, settings.Password);
requestBuilder.Headers.Add("Accept-Encoding", "gzip,deflate");
var httpRequest = requestBuilder.Build();
HttpResponse response;
try
{
response = _httpClient.Execute(httpRequest);
}
catch (HttpException ex)
{
throw new DownloadClientException("Unable to connect to Hadouken, please check your settings", ex);
}
catch (WebException ex)
{
throw new DownloadClientUnavailableException("Unable to connect to Hadouken, please check your settings", ex);
}
var result = Json.Deserialize <JsonRpcResponse <T> >(response.Content);
if (result.Error != null)
{
throw new DownloadClientException("Error response received from Hadouken: {0}", result.Error.ToString());
}
return(result.Result);
}
private IEnumerable <IndexerRequest> GetPagedRequests(BroadcastheNetTorrentQuery parameters, int results, int offset)
{
var builder = new JsonRpcRequestBuilder(Settings.BaseUrl)
.Call("getTorrents", Settings.ApiKey, parameters, results, offset);
builder.SuppressHttpError = true;
yield return(new IndexerRequest(builder.Build()));
}
private IEnumerable <IndexerRequest> GetPagedRequests(int maxPages, BroadcastheNetTorrentQuery parameters)
{
var builder = new JsonRpcRequestBuilder(Settings.BaseUrl)
.Call("getTorrents", Settings.ApiKey, parameters, PageSize, 0);
builder.SuppressHttpError = true;
for (var page = 0; page < maxPages; page++)
{
builder.JsonParameters[3] = page * PageSize;
yield return(new IndexerRequest(builder.Build()));
}
}
private JsonRpcRequestBuilder BuildRequest(DelugeSettings settings)
{
string url = HttpRequestBuilder.BuildBaseUrl(settings.UseSsl, settings.Host, settings.Port, settings.UrlBase);
var requestBuilder = new JsonRpcRequestBuilder(url);
requestBuilder.LogResponseContent = true;
requestBuilder.Resource("json");
requestBuilder.PostProcess += r => r.RequestTimeout = TimeSpan.FromSeconds(15);
AuthenticateClient(requestBuilder, settings);
return(requestBuilder);
}
private IEnumerable <IndexerRequest> GetPagedRequests(int maxPages, BroadcastheNetTorrentQuery parameters)
{
if (parameters == null)
{
parameters = new BroadcastheNetTorrentQuery();
}
var builder = new JsonRpcRequestBuilder(Settings.BaseUrl, "getTorrents", new object[] { Settings.ApiKey, parameters, PageSize, 0 });
builder.SupressHttpError = true;
for (var page = 0; page < maxPages; page++)
{
builder.Parameters[3] = page * PageSize;
yield return(new IndexerRequest(builder.Build("")));
}
}
private T ProcessRequest <T>(NzbgetSettings settings, string method, params object[] parameters)
{
var baseUrl = HttpRequestBuilder.BuildBaseUrl(settings.UseSsl, settings.Host, settings.Port, "jsonrpc");
var requestBuilder = new JsonRpcRequestBuilder(baseUrl, method, parameters);
requestBuilder.LogResponseContent = true;
requestBuilder.NetworkCredential = new NetworkCredential(settings.Username, settings.Password);
var httpRequest = requestBuilder.Build();
HttpResponse response;
try
{
response = _httpClient.Execute(httpRequest);
}
catch (HttpException ex)
{
if (ex.Response.StatusCode == HttpStatusCode.Unauthorized)
{
throw new DownloadClientAuthenticationException("Authentication failed for NzbGet, please check your settings", ex);
}
throw new DownloadClientException("Unable to connect to NzbGet. " + ex.Message, ex);
}
catch (WebException ex)
{
throw new DownloadClientUnavailableException("Unable to connect to NzbGet. " + ex.Message, ex);
}
var result = Json.Deserialize <JsonRpcResponse <T> >(response.Content);
if (result.Error != null)
{
throw new DownloadClientException("Error response received from nzbget: {0}", result.Error.ToString());
}
return(result.Result);
}
private string ProcessRequest(XbmcSettings settings, string method, params object[] parameters)
{
var url = string.Format(@"http://{0}/jsonrpc", settings.Address);
var requestBuilder = new JsonRpcRequestBuilder(url, method, parameters);
requestBuilder.LogResponseContent = true;
var request = requestBuilder.Build();
if (!settings.Username.IsNullOrWhiteSpace())
{
request.AddBasicAuthentication(settings.Username, settings.Password);
}
var response = _httpClient.Execute(request);
_logger.Trace("Response: {0}", response.Content);
CheckForError(response);
return(response.Content);
}
private string ProcessRequest(XbmcSettings settings, string method, params object[] parameters)
{
var url = HttpRequestBuilder.BuildBaseUrl(settings.UseSsl, settings.Host, settings.Port, "jsonrpc");
var requestBuilder = new JsonRpcRequestBuilder(url, method, parameters);
requestBuilder.LogResponseContent = true;
var request = requestBuilder.Build();
if (!settings.Username.IsNullOrWhiteSpace())
{
request.Credentials = new BasicNetworkCredential(settings.Username, settings.Password);
}
var response = _httpClient.Execute(request);
_logger.Trace("Response: {0}", response.Content);
CheckForError(response);
return(response.Content);
}
