public Uri BuildUri(IronClientConfig config, string path, NameValueCollection query)
{
if (path.StartsWith("/"))
{
path = path.Substring(1);
}
string queryString = "";
if (query != null && query.Count > 0)
{
NameValueCollection httpValueCollection = HttpUtility.ParseQueryString("");
httpValueCollection.Add(query);
queryString = httpValueCollection.ToString();
}
var scheme = String.IsNullOrEmpty(config.Scheme) ? Uri.UriSchemeHttps : config.Scheme;
var uriBuilder = new UriBuilder(scheme, config.Host)
{
Path = string.Format("{0}/{1}", config.ApiVersion, path.Replace("{Project ID}", config.ProjectId)),
Query = queryString
};
if (config.Port.HasValue)
{
uriBuilder.Port = config.Port.Value;
}
return(uriBuilder.Uri);
}
public static void SetOauthHeaderIfRequired(IronClientConfig config, IRestClientRequest request, HttpRequestHeaders headers)
{
if (request.AuthTokenLocation == AuthTokenLocation.Header)
{
headers.Authorization = new AuthenticationHeaderValue("OAuth", config.Token);
}
}
public override void SetOauthHeaderIfRequired(IronClientConfig config, IRestClientRequest request, HttpRequestHeaders headers)
{
if (request.AuthTokenLocation == AuthTokenLocation.Header)
{
String token = tokenContainer.getToken();
headers.Authorization = new AuthenticationHeaderValue("OAuth", token);
}
}
static void Main(string[] args)
{
var config = new IronClientConfig { ProjectId = "ABC", Token = "XYZ", Host = "mq-aws-us-east-1-1.iron.io" };
var iromMq = IronSharp.IronMQ.Client.New(config);
var queue = iromMq.Queue("sampleQueue");
var errorQueue = iromMq.Queue("errorQueue");
var batchLoop = true;
while (batchLoop)
{
var reserved = queue.Reserve(batchSize, timeout);
if(reserved.Messages.Count == 0) {
Console.WriteLine("Ending worker - queue is empty");
break;
}
Console.WriteLine("Reserved {0} messages (requested {1})", reserved.Messages.Count, batchSize);
foreach (var msg in reserved.Messages)
{
// Before processing message, check time restriction
if (timeRemaining() < 3 * avgMsgProcTimeMinutes) // A coefficient for extra buffer
{
Console.WriteLine("Stopped processing messages due to out of time");
batchLoop = false;
break;
}
if (msg.ReservedCount > 5)
{
errorQueue.Post(msg);
msg.Delete();
continue;
}
try
{
processMsg(msg);
if (!msg.Delete())
{
Console.WriteLine("Processed message but was unable to delete: Id:{0}, Body:{1}", msg.Id, msg.Body);
}
}
catch (Exception e)
{
Console.WriteLine("Experienced processing error for msg Id:{0}, Body:{1}, err: {1}", msg.Id, msg.Body, e.ToString());
msg.Release(10 * msg.ReservedCount); // Try to release if timeout hasn't happened already
}
}
if (timeRemaining() < avgMsgProcTimeMinutes * batchSize)
{
Console.WriteLine("Stopped reserving batches due to out of time");
batchLoop = false;
break;
}
}
}
/// <summary>
/// Generates the Uri for the specified request.
/// </summary>
/// <param name="config">The project id and other config values</param>
/// <param name="request">The request endpoint and query parameters</param>
/// <param name="token">(optional) The token to use for the building the request uri if different than the Token specified in the config.</param>
public Uri BuildRequestUri(IronClientConfig config, IRestClientRequest request, string token = null)
{
if (string.IsNullOrEmpty(token))
{
token = config.Token;
}
SetOathQueryParameterIfRequired(request, token);
return(BuildUri(config, request.EndPoint, request.Query));
}
public RestResponse <T> Get <T>(IronClientConfig config, string endPoint, NameValueCollection query = null) where T : class
{
var requestBuilder = new HttpRequestMessageBuilder(config, this, new RestClientRequest
{
EndPoint = endPoint,
Query = query,
Method = HttpMethod.Get
});
return(new RestResponse <T>(AttemptRequest(config.SharpConfig, requestBuilder)));
}
public static async Task <RestResponse <T> > Get <T>(IronClientConfig config, string endPoint, NameValueCollection query = null) where T : class
{
HttpRequestMessage request = RestUtility.BuildIronRequest(config, new RestClientRequest
{
EndPoint = endPoint,
Query = query,
Method = HttpMethod.Get
});
return(new RestResponse <T>(await AttemptRequestAync(config.SharpConfig, request)));
}
public Task <HttpResponseMessage> Execute(IronClientConfig config, IRestClientRequest request)
{
var requestBuilder = new HttpRequestMessageBuilder(config, this, new RestClientRequest
{
EndPoint = request.EndPoint,
Query = request.Query,
Method = request.Method,
Content = request.Content
});
return(httpClient.SendAsync(requestBuilder.Build()));
}
private static void ApplyOverrides(IronClientConfig targetConfig, IronClientConfig overrideConfig)
{
if (overrideConfig == null)
{
return;
}
targetConfig.ProjectId = string.IsNullOrEmpty(overrideConfig.ProjectId) ? targetConfig.ProjectId : overrideConfig.ProjectId;
targetConfig.Token = string.IsNullOrEmpty(overrideConfig.Token) ? targetConfig.Token : overrideConfig.Token;
targetConfig.Host = string.IsNullOrEmpty(overrideConfig.Host) ? targetConfig.Host : overrideConfig.Host;
targetConfig.ApiVersion = overrideConfig.ApiVersion.HasValue ? overrideConfig.ApiVersion : targetConfig.ApiVersion;
}
static void Main(string[] args)
{
var config = new IronClientConfig { ProjectId = "ABC", Token = "XYZ", Host = "mq-aws-us-east-1-1.iron.io" };
var iromMq = IronSharp.IronMQ.Client.New(config);
var queue = iromMq.Queue("sampleQueue");
for (var x = 0; x < 1000; x++)
{
var messageId = queue.Post("Msg: " + x);
}
}
public static IronClientConfig Load(IronProduct product = IronProduct.AllProducts, IronClientConfig overrideConfig = null, string env = null)
{
string homeIronDotJson = Path.Combine(GetHomeDirectory(), ".iron.json");
string appIronDotJson = Path.Combine(GetAppDirectory(), "iron.json");
IronClientConfig home = ParseJsonFile(product, homeIronDotJson, env);
IronClientConfig app = ParseJsonFile(product, appIronDotJson, env);
ApplyOverrides(home, app);
ApplyOverrides(home, overrideConfig);
return(home);
}
internal IronWorkerRestClient(IronClientConfig config)
{
_config = LazyInitializer.EnsureInitialized(ref config);
if (string.IsNullOrEmpty(Config.Host))
{
Config.Host = IronWorkCloudHosts.DEFAULT;
}
if (config.ApiVersion == default (int))
{
config.ApiVersion = 2;
}
}
private static void ApplyOverrides(IronClientConfig targetConfig, IronClientConfig overrideConfig)
{
if (overrideConfig == null)
{
return;
}
targetConfig.ProjectId = string.IsNullOrEmpty(overrideConfig.ProjectId) ? targetConfig.ProjectId : overrideConfig.ProjectId;
targetConfig.Token = string.IsNullOrEmpty(overrideConfig.Token) ? targetConfig.Token : overrideConfig.Token;
targetConfig.Host = string.IsNullOrEmpty(overrideConfig.Host) ? targetConfig.Host : overrideConfig.Host;
targetConfig.Scheme = string.IsNullOrEmpty(overrideConfig.Scheme) ? targetConfig.Scheme : overrideConfig.Scheme;
targetConfig.ApiVersion = overrideConfig.ApiVersion == default(int) ? targetConfig.ApiVersion : overrideConfig.ApiVersion;
targetConfig.Port = overrideConfig.Port.HasValue ? overrideConfig.Port : targetConfig.Port;
targetConfig.Keystone = overrideConfig.Keystone == null ? targetConfig.Keystone : overrideConfig.Keystone;
}
public static Task <HttpResponseMessage> Execute(IronClientConfig config, IRestClientRequest request)
{
HttpRequestMessage httpRequest = RestUtility.BuildIronRequest(config, new RestClientRequest
{
EndPoint = request.EndPoint,
Query = request.Query,
Method = request.Method,
Content = request.Content
});
using (var client = CreateHttpClient())
{
return(client.SendAsync(httpRequest));
}
}
public static IronClientConfig ParseJsonFile(IronProduct product, string filePath, string env = null)
{
JsonDotConfigModel config = LoadJson(filePath, env);
var settings = new IronClientConfig
{
ProjectId = config.ProjectId,
Token = config.Token,
Host = config.Host
};
ApplyOverrides(settings, GetProductOverride(product, config));
return(settings);
}
public static Uri BuildProjectUri(IronClientConfig config, string path, NameValueCollection query)
{
if (path.StartsWith("/"))
{
path = path.Substring(1);
}
string queryString = BuildQueryString(query);
var uriBuilder = new UriBuilder(Uri.UriSchemeHttps, config.Host)
{
Path = String.Format("{0}/{1}", config.ApiVersion, path.Replace("{Project ID}", config.ProjectId)),
Query = queryString
};
return(uriBuilder.Uri);
}
public RestResponse <T> Post <T>(IronClientConfig config, string endPoint, object payload = null, NameValueCollection query = null) where T : class
{
var requestBuilder = new HttpRequestMessageBuilder(config, this, new RestClientRequest
{
EndPoint = endPoint,
Query = query,
Method = HttpMethod.Post
});
IronSharpConfig sharpConfig = config.SharpConfig;
if (payload != null)
{
requestBuilder.Payload = payload;
}
return(new RestResponse <T>(AttemptRequest(sharpConfig, requestBuilder)));
}
public static async Task <RestResponse <T> > Put <T>(IronClientConfig config, string endPoint, object payload, NameValueCollection query = null) where T : class
{
HttpRequestMessage request = RestUtility.BuildIronRequest(config, new RestClientRequest
{
EndPoint = endPoint,
Query = query,
Method = HttpMethod.Put
});
IronSharpConfig sharpConfig = config.SharpConfig;
if (payload != null)
{
request.Content = new JsonContent(payload);
}
return(new RestResponse <T>(await AttemptRequestAync(sharpConfig, request)));
}
public static HttpRequestMessage BuildIronRequest(IronClientConfig config, IRestClientRequest request)
{
SetOathQueryParameterIfRequired(request, config.Token);
var httpRequest = new HttpRequestMessage
{
Content = request.Content,
RequestUri = BuildProjectUri(config, request.EndPoint, request.Query),
Method = request.Method
};
HttpRequestHeaders headers = httpRequest.Headers;
SetOauthHeaderIfRequired(config, request, headers);
headers.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip"));
headers.AcceptEncoding.Add(new StringWithQualityHeaderValue("deflate"));
headers.Accept.Add(new MediaTypeWithQualityHeaderValue(request.Accept));
return(httpRequest);
}
public static IronClientConfig LoadFromEnvironment(IronProduct product, EnvironmentVariableTarget target = EnvironmentVariableTarget.Process)
{
var baseConfig = new IronClientConfig
{
ProjectId = GetEnvironmentValue <string>(IronProduct.AllProducts, "projectid", target),
Token = GetEnvironmentValue <string>(IronProduct.AllProducts, "token", target)
};
var productConfig = new IronClientConfig
{
ProjectId = GetEnvironmentValue <string>(product, "projectid", target),
Token = GetEnvironmentValue <string>(product, "token", target),
Host = GetEnvironmentValue <string>(product, "host", target)
};
ApplyOverrides(baseConfig, productConfig);
return(baseConfig);
}
private static IronClientConfig GetProductOverride(IronProduct product, JsonDotConfigModel config)
{
IronClientConfig productOverride = null;
switch (product)
{
case IronProduct.IronCache:
productOverride = config.IronCache;
break;
case IronProduct.IronMQ:
productOverride = config.IronMQ;
break;
case IronProduct.IronWorker:
productOverride = config.IronWoker;
break;
}
return(productOverride);
}
/// <summary>
/// Creates a new client using the specified configuration and optional <param name="env"></param> paramter to specificy which enivonment to use when loading default values;
/// </summary>
/// <param name="config">The explicitly specified configuration values</param>
/// <param name="env">The environment key as it appears in the iron.json file. See http://dev.iron.io/worker/reference/cli/#upload_with_multiple_environments for an example layout</param>
public static IronWorkerRestClient @New(IronClientConfig config, string env = null)
{
IronClientConfig hierarchyConfig = IronDotConfigManager.Load(IronProduct.IronWorker, config, env);
return new IronWorkerRestClient(hierarchyConfig);
}
