public static Task<ServiceId> AddServiceAsync(this IContentDeliveryService service, ServiceData serviceData, CancellationToken cancellationToken)
{
if (service == null)
throw new ArgumentNullException("service");
return TaskBlocks.Using(
() => service.PrepareAddServiceAsync(serviceData, cancellationToken),
task => task.Result.SendAsync(cancellationToken).Select(innerTask => innerTask.Result.Item2));
}
public static Task UpdateServiceAsync(this IContentDeliveryService service, ServiceId serviceId, ServiceData updatedServiceData, CancellationToken cancellationToken)
{
if (service == null)
throw new ArgumentNullException("service");
return TaskBlocks.Using(
() => service.PrepareUpdateServiceAsync(serviceId, updatedServiceData, cancellationToken),
task => task.Result.SendAsync(cancellationToken));
}
public async Task TestCreateService()
{
using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())
{
string domainName = "www.mywebsite.com";
string ruleName = "mywebsite.com";
string ruleUri = "www.mywebsite.com";
string serviceOriginName = "example.com";
string cacheRuleName = "default";
string cacheRuleUri = "www.mywebsite.com";
string restrictionRuleName = "mywebsite.com";
string restrictionRuleReferrer = "www.mywebsite.com";
string serviceRestrictionName = "website only";
string serviceName = "testService";
FlavorId flavorId = new FlavorId("cdn");
cancellationTokenSource.CancelAfter(TestTimeout(TimeSpan.FromSeconds(10)));
CancellationToken cancellationToken = cancellationTokenSource.Token;
ServiceProtocol serviceProtocol = ServiceProtocol.Http;
ServiceDomain sd = new ServiceDomain(domainName, serviceProtocol);
ImmutableArray<ServiceDomain>.Builder sdbuilder = ImmutableArray.CreateBuilder<ServiceDomain>();
sdbuilder.Add(sd);
ImmutableArray<ServiceDomain> domains = sdbuilder.ToImmutable();
ServiceOriginRule sor = new ServiceOriginRule(ruleName, ruleUri);
ImmutableArray<ServiceOriginRule>.Builder sorbuilder = ImmutableArray.CreateBuilder<ServiceOriginRule>();
sorbuilder.Add(sor);
ImmutableArray<ServiceOriginRule> rules = sorbuilder.ToImmutable();
ServiceOrigin so = new ServiceOrigin(serviceOriginName, 80, false, rules);
ImmutableArray<ServiceOrigin>.Builder sobuilder = ImmutableArray.CreateBuilder<ServiceOrigin>();
sobuilder.Add(so);
ImmutableArray<ServiceOrigin> origins = sobuilder.ToImmutable();
ServiceCacheRule scr = new ServiceCacheRule(cacheRuleName, cacheRuleUri);
ImmutableArray<ServiceCacheRule>.Builder scrbuilder = ImmutableArray.CreateBuilder<ServiceCacheRule>();
scrbuilder.Add(scr);
ImmutableArray<ServiceCacheRule> scrules = scrbuilder.ToImmutable();
ImmutableArray<ServiceCache>.Builder scbuilder = ImmutableArray.CreateBuilder<ServiceCache>();
ServiceCache sc = new ServiceCache(cacheRuleName, new TimeSpan(0, 0, 3600), scrules);
scbuilder.Add(sc);
ImmutableArray<ServiceCache> caching = scbuilder.ToImmutable();
caching = new ImmutableArray<ServiceCache>();
ImmutableArray<ServiceRestrictionRule>.Builder srrbuilder = ImmutableArray.CreateBuilder<ServiceRestrictionRule>();
ServiceRestrictionRule srr = new ServiceRestrictionRule(restrictionRuleName, restrictionRuleReferrer);
srrbuilder.Add(srr);
ImmutableArray<ServiceRestrictionRule> srrules = srrbuilder.ToImmutable();
srrules = new ImmutableArray<ServiceRestrictionRule>();
ImmutableArray<ServiceRestriction>.Builder rbuilder = ImmutableArray.CreateBuilder<ServiceRestriction>();
ServiceRestriction sr = new ServiceRestriction(serviceRestrictionName, srrules);
rbuilder.Add(sr);
ImmutableArray<ServiceRestriction> restrictions = rbuilder.ToImmutable();
restrictions = new ImmutableArray<ServiceRestriction>();
ServiceData serviceData = new ServiceData(serviceName, flavorId, domains, origins, caching, restrictions);
//
//ServiceData sed = new ServiceData(serviceName, flavorId, domains, origins, caching, restrictions);
//CancellationToken cn = new CancellationToken();
//ServiceId x = await cdc.AddServiceAsync(serviceData, cn);
//
IContentDeliveryService service = CreateService();
using (AddServiceApiCall apiCall = await service.PrepareAddServiceAsync(serviceData, cancellationToken))
{
Tuple<HttpResponseMessage, ServiceId> response = await apiCall.SendAsync(cancellationToken);
Assert.IsNotNull(response);
var responseMessage = response.Item1;
Assert.IsNotNull(responseMessage);
Assert.AreEqual(HttpStatusCode.OK, responseMessage.StatusCode);
ServiceId serviceID = response.Item2;
Assert.IsNotNull(serviceID);
}
using (GetHomeApiCall apiCall = await service.PrepareGetHomeAsync(cancellationToken))
{
Tuple<HttpResponseMessage, HomeDocument> response = await apiCall.SendAsync(cancellationToken);
Assert.IsNotNull(response);
var responseMessage = response.Item1;
Assert.IsNotNull(responseMessage);
Assert.AreEqual(HttpStatusCode.OK, responseMessage.StatusCode);
HomeDocument homeDocument = response.Item2;
CheckHomeDocument(homeDocument);
}
}
}
public async Task TestGetService()
{
using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())
{
cancellationTokenSource.CancelAfter(TestTimeout(TimeSpan.FromSeconds(30)));
CancellationToken cancellationToken = cancellationTokenSource.Token;
IContentDeliveryService service = CreateService();
string name = TestServicePrefix + Path.GetRandomFileName();
FlavorId flavorId = (await service.ListFlavorsAsync(cancellationToken)).First().Id;
ImmutableArray<ServiceDomain> domains = ImmutableArray.Create(new ServiceDomain(TestDomainPrefix + "cdn.example.com", ServiceProtocol.Http));
ImmutableArray<ServiceOrigin> origins = ImmutableArray.Create(new ServiceOrigin("rackspace.com", 80, false, default(ImmutableArray<ServiceOriginRule>)));
ImmutableArray<ServiceCache> caching = default(ImmutableArray<ServiceCache>);
ImmutableArray<ServiceRestriction> restrictions = default(ImmutableArray<ServiceRestriction>);
ServiceData serviceData = new ServiceData(name, flavorId, domains, origins, caching, restrictions);
ServiceId serviceId = await service.AddServiceAsync(serviceData, cancellationToken);
Assert.IsNotNull(serviceId);
using (GetServiceApiCall apiCall = await service.PrepareGetServiceAsync(serviceId, cancellationToken))
{
Tuple<HttpResponseMessage, Service> response = await apiCall.SendAsync(cancellationToken);
Assert.IsNotNull(response);
var responseMessage = response.Item1;
Assert.IsNotNull(responseMessage);
Assert.AreEqual(HttpStatusCode.OK, responseMessage.StatusCode);
Service serviceResult = response.Item2;
Assert.IsNotNull(serviceResult);
}
await service.RemoveServiceAsync(serviceId, cancellationToken);
}
}
public async Task TestAddRemoveServiceExtension()
{
using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())
{
cancellationTokenSource.CancelAfter(TestTimeout(TimeSpan.FromSeconds(10)));
CancellationToken cancellationToken = cancellationTokenSource.Token;
IContentDeliveryService service = CreateService();
string name = TestServicePrefix + Path.GetRandomFileName();
FlavorId flavorId = (await service.ListFlavorsAsync(cancellationToken)).First().Id;
ImmutableArray<ServiceDomain> domains = ImmutableArray.Create(new ServiceDomain(TestDomainPrefix + "cdn.example.com", ServiceProtocol.Http));
ImmutableArray<ServiceOrigin> origins = ImmutableArray.Create(new ServiceOrigin("rackspace.com", 80, false, default(ImmutableArray<ServiceOriginRule>)));
ImmutableArray<ServiceCache> caching = default(ImmutableArray<ServiceCache>);
ImmutableArray<ServiceRestriction> restrictions = default(ImmutableArray<ServiceRestriction>);
ServiceData serviceData = new ServiceData(name, flavorId, domains, origins, caching, restrictions);
ServiceId serviceId = await service.AddServiceAsync(serviceData, cancellationToken);
Assert.IsNotNull(serviceId);
await service.RemoveServiceAsync(serviceId, cancellationToken);
}
}
