public void Test_Offline_License_Failure()
{
var clock = new OffsetClock("2017-04-25", "2017-04-25");
var mgr = new LicenseManagerSingleton(ImazenPublicKeys.Test, clock)
{
Cache = new StringCacheMem()
};
var conf = new Config();
conf.Plugins.LicenseScope = LicenseAccess.Local;
conf.Plugins.Install(new LicensedPlugin(mgr, clock, "R4Creative"));
Assert.Empty(mgr.GetIssues());
Assert.Null(mgr.GetAllLicenses().FirstOrDefault());
var result = new Computation(conf, ImazenPublicKeys.Test, mgr, mgr, clock, true);
Assert.False(result.LicensedForRequestUrl(new Uri("http://acme.com")));
conf.Plugins.AddLicense(LicenseStrings.Offlinev4DomainAcmeComCreative);
Assert.NotNull(mgr.GetAllLicenses().First());
result = new Computation(conf, ImazenPublicKeys.Test, mgr, mgr, clock, true);
Assert.True(result.LicensedForRequestUrl(new Uri("http://acme.com")));
Assert.Empty(mgr.GetIssues());
Assert.NotNull(conf.GetDiagnosticsPage());
Assert.NotNull(conf.GetLicensesPage());
}
public void Test_License_Enforcer_Watermark()
{
var clock = new RealClock();
var mgr = new LicenseManagerSingleton(ImazenPublicKeys.Test, clock, new StringCacheMem());
var request = new RequestUrlProvider();
var conf = new Config();
conf.Plugins.LicenseScope = LicenseAccess.Local;
conf.Plugins.AddLicense(LicenseStrings.Offlinev4DomainAcmeComCreative);
conf.Plugins.LicenseError = LicenseErrorAction.Watermark;
conf.Plugins.AddLicensedDomainMapping("localhost", "acme.com");
conf.Plugins.Install(new Gradient());
conf.Plugins.Install(new EmptyLicenseEnforcedPlugin(new LicenseEnforcer <EmptyLicenseEnforcedPlugin>(mgr, mgr, request.Get).EnableEnforcement(), "R4Creative"));
request.Url = null;
Assert.False(IsWatermarking(conf, mgr));
request.Url = new Uri("http://acme.com");
Assert.False(IsWatermarking(conf, mgr));
request.Url = new Uri("http://subdomain.acme.com");
Assert.False(IsWatermarking(conf, mgr));
request.Url = new Uri("http://localhost");
Assert.False(IsWatermarking(conf, mgr));
// We should watermark unlicensed domains
request.Url = new Uri("http://other.co");
Assert.True(IsWatermarking(conf, mgr));
Assert.True(IsWatermarking(conf, mgr));
Assert.Empty(mgr.GetIssues());
}
public void Test_Offline_License_Success()
{
var clock = new OffsetClock("2017-04-25", "2017-04-25");
var mgr = new LicenseManagerSingleton(ImazenPublicKeys.Test, clock, new StringCacheMem());
var conf = new MockConfig(mgr, clock, new [] { "R4Creative" }, new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>("localhost", "acme.com")
});
conf.AddLicense(LicenseStrings.OfflineV4DomainAcmeComCreative);
Assert.Equal(0, mgr.WaitForTasks());
Assert.Empty(mgr.GetIssues());
Assert.Single(mgr.GetAllLicenses());
Assert.NotNull(mgr.GetAllLicenses().First());
var result = new Computation(conf, ImazenPublicKeys.Test, mgr, mgr, clock, true);
Assert.True(result.LicensedForRequestUrl(new Uri("http://acme.com")));
Assert.True(result.LicensedForRequestUrl(new Uri("http://subdomain.acme.com")));
Assert.True(result.LicensedForRequestUrl(new Uri("http://localhost")));
Assert.False(result.LicensedForRequestUrl(new Uri("http://other.com")));
Assert.Equal(0, mgr.WaitForTasks());
Assert.Empty(mgr.GetIssues());
Assert.NotNull(conf.GetLicensesPage());
}
public async void TestAGPL()
{
using (var contentRoot = new TempContentRoot()
.AddResource("images/fire.jpg", "TestFiles.fire-umbrella-small.jpg"))
{
var clock = new RealClock();
var mgr = new LicenseManagerSingleton(ImazenPublicKeys.Test, clock, new StringCacheMem());
var licensing = new Licensing(mgr);
using var host = await StartAsyncWithOptions(new ImageflowMiddlewareOptions ()
{
Licensing = licensing,
MyOpenSourceProjectUrl = "https://github.com/username/project",
EnforcementMethod = EnforceLicenseWith.RedDotWatermark
}.MapPath("/", Path.Combine(contentRoot.PhysicalPath, "images")));
// Create an HttpClient to send requests to the TestServer
using var client = host.GetTestClient();
using var licensedResponse = await client.GetAsync("/fire.jpg?w=1");
licensedResponse.EnsureSuccessStatusCode();
var page = licensing.Result.ProvidePublicLicensesPage();
Assert.Contains("License Validation OFF", page);
Assert.Contains("No license keys found.", page);
Assert.DoesNotContain("You must purchase a license key or comply with the AGPLv3.", page);
Assert.DoesNotContain("To get a license key", page);
Assert.Contains("You are using EnforceLicenseWith.RedDotWatermark", page);
await host.StopAsync(CancellationToken.None);
}
}
public void Test_License_Enforcer_Exception_Web_Config()
{
var clock = new RealClock();
var mgr = new LicenseManagerSingleton(ImazenPublicKeys.Test, clock, new StringCacheMem());
var request = new RequestUrlProvider();
var conf = new Config(new ResizerSection(
@"<resizer><licenses licenseError='exception' licenseScope='local'>
<maphost from='localhost' to='acme.com' />
<license>" + LicenseStrings.Offlinev4DomainAcmeComCreative + "</license></licenses>" +
"<plugins><add name='Gradient'/></plugins></resizer>"));
conf.Plugins.Install(new EmptyLicenseEnforcedPlugin(new LicenseEnforcer <EmptyLicenseEnforcedPlugin>(mgr, mgr, request.Get).EnableEnforcement(), "R4Creative"));
request.Url = null;
Assert.False(IsWatermarking(conf, mgr));
request.Url = new Uri("http://acme.com");
Assert.False(IsWatermarking(conf, mgr));
request.Url = new Uri("http://subdomain.acme.com");
Assert.False(IsWatermarking(conf, mgr));
request.Url = new Uri("http://localhost");
Assert.False(IsWatermarking(conf, mgr));
request.Url = new Uri("http://other.co");
var e = Record.Exception(() => IsWatermarking(conf, mgr));
Assert.NotNull(e);
Assert.IsType <LicenseException>(e);
Assert.Empty(mgr.GetIssues());
}
public void Test_Offline_License_Success()
{
var clock = new OffsetClock("2017-04-25", "2017-04-25");
var mgr = new LicenseManagerSingleton(ImazenPublicKeys.Test, clock)
{
Cache = new StringCacheMem()
};
var conf = new Config(new ResizerSection(
@"<resizer><licenses>
<maphost from='localhost' to='acme.com' />
<license>" + LicenseStrings.Offlinev4DomainAcmeComCreative + "</license></licenses></resizer>"));
conf.Plugins.LicenseScope = LicenseAccess.Local;
conf.Plugins.Install(new LicensedPlugin(mgr, clock, "R4Creative"));
Assert.Equal(0, mgr.WaitForTasks());
Assert.Empty(mgr.GetIssues());
Assert.NotNull(mgr.GetAllLicenses().First());
var result = new Computation(conf, ImazenPublicKeys.Test, mgr, mgr, clock, true);
Assert.True(result.LicensedForRequestUrl(new Uri("http://acme.com")));
Assert.True(result.LicensedForRequestUrl(new Uri("http://subdomain.acme.com")));
Assert.True(result.LicensedForRequestUrl(new Uri("http://localhost")));
Assert.False(result.LicensedForRequestUrl(new Uri("http://other.com")));
Assert.Equal(0, mgr.WaitForTasks());
Assert.Empty(mgr.GetIssues());
Assert.NotNull(conf.GetDiagnosticsPage());
Assert.NotNull(conf.GetLicensesPage());
}
public void Test_Caching_With_Timeout()
{
if (Environment.GetEnvironmentVariable("APPVEYOR") == "True")
{
return;
}
var clock = new OffsetClock("2017-04-25", "2017-04-25");
var cache = new StringCacheMem();
// Populate cache
{
var mgr = new LicenseManagerSingleton(ImazenPublicKeys.Test, clock, cache);
MockHttpHelpers.MockRemoteLicense(mgr, HttpStatusCode.OK, LicenseStrings.EliteSubscriptionRemote,
null);
var conf = new MockConfig(mgr, clock, new [] { "R_Elite", "R4Elite" }, new List <KeyValuePair <string, string> >());
conf.AddLicense(LicenseStrings.EliteSubscriptionPlaceholder);
mgr.WaitForTasks();
var result = new Computation(conf, ImazenPublicKeys.Test, mgr, mgr, clock, true);
Assert.True(result.LicensedForRequestUrl(new Uri("http://anydomain")));
Assert.Empty(mgr.GetIssues());
Assert.NotNull(conf.GetLicensesPage());
}
// Use cache
{
var mgr = new LicenseManagerSingleton(ImazenPublicKeys.Test, clock, cache)
{
SkipHeartbeatsIfDiskCacheIsFresh = 0
};
MockHttpHelpers.MockRemoteLicenseException(mgr, WebExceptionStatus.NameResolutionFailure);
var conf = new MockConfig(mgr, clock, new [] { "R_Elite", "R4Elite" }, new List <KeyValuePair <string, string> >());
try {
conf.AddLicense(LicenseStrings.EliteSubscriptionPlaceholder);
conf.FireHeartbeat();
mgr.WaitForTasks();
var result = new Computation(conf, ImazenPublicKeys.Test, mgr, mgr, clock, true);
Assert.True(result.LicensedForRequestUrl(new Uri("http://anydomain")));
Assert.NotNull(conf.GetLicensesPage());
Assert.Single(mgr.GetIssues());
} catch {
output.WriteLine(conf.GetLicensesPage());
throw;
}
}
}
public async void TestSiteLicense()
{
using (var contentRoot = new TempContentRoot()
.AddResource("images/fire.jpg", "TestFiles.fire-umbrella-small.jpg"))
{
var clock = new FakeClock("2017-04-25", "2017-04-25");
var set = LicenseStrings.GetSets("SiteWideImageflow").First();
var mgr = new LicenseManagerSingleton(ImazenPublicKeys.Test, clock, new StringCacheMem());
MockHttpHelpers.MockRemoteLicense(mgr, HttpStatusCode.OK, set.Remote, null);
var url = new RequestUrlProvider();
var licensing = new Licensing(mgr, url.Get);
using var host = await StartAsyncWithOptions(new ImageflowMiddlewareOptions ()
{
Licensing = licensing,
MyOpenSourceProjectUrl = null
}
.SetLicenseKey (EnforceLicenseWith.Http402Error,
set.Placeholder)
.MapPath("/", Path.Combine(contentRoot.PhysicalPath, "images")));
// Create an HttpClient to send requests to the TestServer
using var client = host.GetTestClient();
mgr.WaitForTasks();
Assert.Empty(mgr.GetIssues());
url.Url = new Uri("https://acme.com");
using var licensedResponse1 = await client.GetAsync("/fire.jpg?w=1");
licensedResponse1.EnsureSuccessStatusCode();
url.Url = new Uri("https://acmestaging.com");
using var licensedResponse2 = await client.GetAsync("/fire.jpg?w=1");
licensedResponse2.EnsureSuccessStatusCode();
url.Url = new Uri("https://subdomain.acme.com");
using var licensedResponse3 = await client.GetAsync("/fire.jpg?w=1");
licensedResponse3.EnsureSuccessStatusCode();
Assert.Empty(mgr.GetIssues());
var page = licensing.Result.ProvidePublicLicensesPage();
Assert.Contains("License Validation ON", page);
Assert.Contains("License key valid for all domains.", page);
Assert.Contains("No resale of usage. Only for organizations with less than 500 employees.", page);
Assert.Contains("You are using EnforceLicenseWith.Http402Error", page);
Assert.Contains("Manage your subscription at https://account.imazen.io", page);
await host.StopAsync(CancellationToken.None);
}
}
public static Mock <HttpMessageHandler> MockRemoteLicenseException(LicenseManagerSingleton mgr, WebExceptionStatus status)
{
var ex = new HttpRequestException("Mock failure", new WebException("Mock failure", status));
var handler = new Mock <HttpMessageHandler>();
var method = handler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>())
.ThrowsAsync(ex);
method.Verifiable("SendAsync must be called");
mgr.SetHttpMessageHandler(handler.Object, true);
return(handler);
}
public async void TestNoLicense()
{
using (var contentRoot = new TempContentRoot()
.AddResource("images/fire.jpg", "TestFiles.fire-umbrella-small.jpg"))
{
var clock = new RealClock();
var mgr = new LicenseManagerSingleton(ImazenPublicKeys.Test, clock, new StringCacheMem());
var licensing = new Licensing(mgr);
using var host = await StartAsyncWithOptions(new ImageflowMiddlewareOptions ()
{
Licensing = licensing,
MyOpenSourceProjectUrl = null,
EnforcementMethod = EnforceLicenseWith.Http402Error
}
.SetDiagnosticsPageAccess (AccessDiagnosticsFrom.None)
.SetDiagnosticsPagePassword ("pass")
.MapPath("/", Path.Combine(contentRoot.PhysicalPath, "images")));
// Create an HttpClient to send requests to the TestServer
using var client = host.GetTestClient();
using var notLicensedResponse = await client.GetAsync("/fire.jpg?w=1");
Assert.Equal(HttpStatusCode.PaymentRequired, notLicensedResponse.StatusCode);
using var licensePageResponse = await client.GetAsync("/imageflow.license");
licensePageResponse.EnsureSuccessStatusCode();
using var notAuthorizedResponse = await client.GetAsync("/imageflow.debug");
Assert.Equal(HttpStatusCode.Unauthorized, notAuthorizedResponse.StatusCode);
using var debugPageResponse = await client.GetAsync("/imageflow.debug?password=pass");
debugPageResponse.EnsureSuccessStatusCode();
var page = licensing.Result.ProvidePublicLicensesPage();
Assert.Contains("License Validation ON", page);
Assert.Contains("No license keys found.", page);
Assert.Contains("You must purchase a license key or comply with the AGPLv3.", page);
Assert.Contains("To get a license key, visit", page);
Assert.Contains("You are using EnforceLicenseWith.Http402Error", page);
await host.StopAsync(CancellationToken.None);
}
}
public void Test_Remote_License_Success()
{
if (Environment.GetEnvironmentVariable("APPVEYOR") == "True")
{
return;
}
var clock = new OffsetClock("2017-04-25", "2017-04-25");
var mgr = new LicenseManagerSingleton(ImazenPublicKeys.Test, clock)
{
Cache = new StringCacheMem()
};
Uri invokedUri = null;
var httpHandler = MockHttpHelpers.MockRemoteLicense(mgr, HttpStatusCode.OK, LicenseStrings.EliteSubscriptionRemote,
(r, c) => { invokedUri = r.RequestUri; });
var conf = new Config();
try {
conf.Plugins.LicenseScope = LicenseAccess.Local;
conf.Plugins.Install(new LicensedPlugin(mgr, clock, "R_Elite"));
conf.Plugins.AddLicense(LicenseStrings.EliteSubscriptionPlaceholder);
Assert.Equal(1, mgr.GetAllLicenses().Count());
Assert.True(mgr.GetAllLicenses().First().IsRemote);
mgr.Heartbeat();
mgr.WaitForTasks();
Assert.Empty(mgr.GetIssues());
Mock.Verify(httpHandler);
Assert.StartsWith(
"https://s3-us-west-2.amazonaws.com/licenses.imazen.net/v1/licenses/latest/",
invokedUri.ToString());
Assert.NotNull(mgr.GetAllLicenses().First().FetchedLicense());
var result = new Computation(conf, ImazenPublicKeys.Test, mgr, mgr, clock, true);
Assert.True(result.LicensedForRequestUrl(new Uri("http://anydomain")));
Assert.Equal(0, mgr.WaitForTasks());
Assert.Empty(mgr.GetIssues());
Assert.NotNull(conf.GetDiagnosticsPage());
Assert.NotNull(conf.GetLicensesPage());
} catch {
output.WriteLine(conf.GetDiagnosticsPage());
throw;
}
}
public void Test_DomainPerCore()
{
// set clock to present
var clock = new FakeClock("2017-04-25", "2017-04-25");
foreach (var set in LicenseStrings.GetSets("PerCore2Domains"))
{
var mgr = new LicenseManagerSingleton(ImazenPublicKeys.Test, clock, new StringCacheMem());
MockHttpHelpers.MockRemoteLicense(mgr, HttpStatusCode.OK, set.Remote, null);
var request = new RequestUrlProvider();
var conf = new Config();
conf.Plugins.LicenseScope = LicenseAccess.Local;
conf.Plugins.AddLicense(set.Placeholder);
conf.Plugins.LicenseError = LicenseErrorAction.Exception;
conf.Plugins.Install(new Gradient());
conf.Plugins.Install(new EmptyLicenseEnforcedPlugin(new LicenseEnforcer <EmptyLicenseEnforcedPlugin>(mgr, mgr, request.Get).EnableEnforcement(), "R_Performance"));
Assert.Equal(1, mgr.WaitForTasks());
// We don't raise exceptions without a request url, unless there are absolutely no valid licenses
request.Url = null;
Assert.False(IsWatermarking(conf, mgr));
// We never watermark outside of http requests
conf.Plugins.LicenseError = LicenseErrorAction.Watermark;
Assert.False(IsWatermarking(conf, mgr));
conf.Plugins.LicenseError = LicenseErrorAction.Exception;
//We should not raise an exception on our domains
request.Url = new Uri("http://acme.com");
Assert.False(IsWatermarking(conf, mgr));
request.Url = new Uri("http://acmestaging.com");
Assert.False(IsWatermarking(conf, mgr));
// We should raise an exception on other domains
request.Url = new Uri("http://other.co");
Assert.Throws <LicenseException>(() => IsWatermarking(conf, mgr));
Assert.Empty(mgr.GetIssues());
}
}
string GetInfo(ILicenseConfig c, LicenseManagerSingleton mgr)
{
var result = new Computation(c, mgr.TrustedKeys, mgr, mgr,
mgr.Clock, true);
var sb = new StringBuilder();
sb.AppendLine($"Plugins.LicenseError = {c.LicenseEnforcement}");
sb.AppendLine($"Plugins.LicenseScope = {c.LicenseScope}");
sb.AppendLine($"Computation.");
sb.AppendLine($"LicensedForAll() => {result.LicensedForAll()}");
sb.AppendLine($"LicensedForSomething() => {result.LicensedForSomething()}");
sb.AppendLine($"LicensedForRequestUrl(null) => {result.LicensedForRequestUrl(null)}");
sb.AppendLine($"LicensedForRequestUrl(new Uri(\"http://other.com\")) => {result.LicensedForRequestUrl(new Uri("http://other.com"))}");
sb.AppendLine($"LicensedForRequestUrl(new Uri(\"http://acme.com\")) => {result.LicensedForRequestUrl(new Uri("http://acme.com"))}");
sb.AppendLine($"GetBuildDate() => {result.GetBuildDate()}");
sb.AppendLine($"ProvideDiagnostics() => {result.ProvideDiagnostics()}");
return(sb.ToString());
}
public void Test_Remote_License_Success()
{
if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("CI")))
{
return;
}
var clock = new OffsetClock("2017-04-25", "2017-04-25");
var mgr = new LicenseManagerSingleton(ImazenPublicKeys.Test, clock, new StringCacheMem());
Uri invokedUri = null;
var httpHandler = MockHttpHelpers.MockRemoteLicense(mgr, HttpStatusCode.OK, LicenseStrings.EliteSubscriptionRemote,
(r, c) => { invokedUri = r.RequestUri; });
var conf = new MockConfig(mgr, clock, new [] { "R_Elite" }, new List <KeyValuePair <string, string> >());
try {
conf.AddLicense(LicenseStrings.EliteSubscriptionPlaceholder);
Assert.Single(mgr.GetAllLicenses());
Assert.True(mgr.GetAllLicenses().First().IsRemote);
conf.FireHeartbeat();
mgr.WaitForTasks();
Assert.Empty(mgr.GetIssues());
Mock.Verify(httpHandler);
Assert.StartsWith(
"https://s3-us-west-2.amazonaws.com/licenses.imazen.net/v1/licenses/latest/",
invokedUri.ToString());
Assert.NotNull(mgr.GetAllLicenses().First().FetchedLicense());
var result = new Computation(conf, ImazenPublicKeys.Test, mgr, mgr, clock, true);
Assert.True(result.LicensedForRequestUrl(new Uri("http://anydomain")));
//TODO: Explore why WaitForTasks() can sometimes return 1
mgr.WaitForTasks();
Assert.Empty(mgr.GetIssues());
Assert.NotNull(conf.GetLicensesPage());
} catch {
output.WriteLine(conf.GetLicensesPage());
throw;
}
}
bool IsWatermarking(Config c, LicenseManagerSingleton mgr)
{
var newInfo = GetInfo(c, mgr);
if (lastInfo != newInfo)
{
lastInfo = newInfo;
output.WriteLine(newInfo);
}
var j = new ImageJob("~/gradient.png", typeof(Bitmap), new Instructions("format=png&width=10"));
c.Build(j);
using (var b = j.Result as Bitmap) {
var cornerPixel = b.GetPixel(b.Width - 1, b.Height - 1);
var watermarked = cornerPixel.ToArgb() == Color.Red.ToArgb();
output.WriteLine($"Watermarked={watermarked}, color={cornerPixel}");
return(watermarked);
}
}
public MockConfig(LicenseManagerSingleton mgr, ILicenseClock clock, string[] codes, IEnumerable <KeyValuePair <string, string> > domainMappings)
{
this.codes = codes;
this.mgr = mgr;
Clock = clock ?? Clock;
mgr.MonitorLicenses(this);
mgr.MonitorHeartbeat(this);
// Ensure our cache is appropriately invalidated
cache = null;
mgr.AddLicenseChangeHandler(this, (me, manager) => me.cache = null);
// And repopulated, so that errors show up.
if (Result == null)
{
throw new ApplicationException("Failed to populate license result");
}
this.domainMappings = domainMappings;
}
public static Mock <HttpMessageHandler> MockRemoteLicense(LicenseManagerSingleton mgr, HttpStatusCode code, string value,
Action <HttpRequestMessage, CancellationToken> callback)
{
var handler = new Mock <HttpMessageHandler>();
var method = handler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>())
.Returns(Task.Run(() => new HttpResponseMessage(code)
{
Content = new StringContent(value, System.Text.Encoding.UTF8)
}));
if (callback != null)
{
method.Callback(callback);
}
method.Verifiable("SendAsync must be called");
mgr.SetHttpMessageHandler(handler.Object, true);
return(handler);
}
public void Test_NoLicense()
{
var clock = new RealClock();
var mgr = new LicenseManagerSingleton(ImazenPublicKeys.Test, clock, new StringCacheMem());
var request = new RequestUrlProvider();
var conf = new Config();
conf.Plugins.LicenseScope = LicenseAccess.Local;
conf.Plugins.Install(new Gradient());
conf.Plugins.Install(new EmptyLicenseEnforcedPlugin(new LicenseEnforcer <EmptyLicenseEnforcedPlugin>(mgr, mgr, request.Get).EnableEnforcement(), "R4Creative"));
// We don't watermark outside of http requests (even if there are no valid licenses)
request.Url = null;
Assert.False(IsWatermarking(conf, mgr));
// But we certainly should be, here
request.Url = new Uri("http://other.co");
Assert.True(IsWatermarking(conf, mgr));
Assert.Empty(mgr.GetIssues());
}
public void Test_Revocations()
{
// set clock to present, and build date to far future
var clock = new FakeClock("2017-04-25", "2022-01-01");
foreach (var set in LicenseStrings.GetSets("Cancelled", "SoftRevocation", "HardRevocation"))
{
output.WriteLine($"Testing revocation for {set.Name}");
var mgr = new LicenseManagerSingleton(ImazenPublicKeys.Test, clock, new StringCacheMem());
MockHttpHelpers.MockRemoteLicense(mgr, HttpStatusCode.OK, set.Remote, null);
var request = new RequestUrlProvider();
var conf = new Config();
conf.Plugins.LicenseScope = LicenseAccess.Local;
conf.Plugins.AddLicense(set.Placeholder);
conf.Plugins.LicenseError = LicenseErrorAction.Watermark;
conf.Plugins.Install(new Gradient());
conf.Plugins.Install(new EmptyLicenseEnforcedPlugin(new LicenseEnforcer <EmptyLicenseEnforcedPlugin>(mgr, mgr, request.Get).EnableEnforcement(), "R4Creative"));
Assert.Equal(1, mgr.WaitForTasks());
request.Url = null;
Assert.False(IsWatermarking(conf, mgr));
// We don't raise exceptions outside of http requests, unless there are absolutely no valid licenses
conf.Plugins.LicenseError = LicenseErrorAction.Exception;
// There are no valid licences
request.Url = null;
Assert.Throws <LicenseException>(() => IsWatermarking(conf, mgr));
// But we certainly should be, here
request.Url = new Uri("http://other.co");
Assert.Throws <LicenseException>(() => IsWatermarking(conf, mgr));
Assert.NotEmpty(mgr.GetIssues());
}
}
internal Licensing(LicenseManagerSingleton mgr, Func <Uri> getCurrentRequestUrl = null)
{
this.mgr = mgr;
this.getCurrentRequestUrl = getCurrentRequestUrl;
}
public async void TestRevocations()
{
using (var contentRoot = new TempContentRoot()
.AddResource("images/fire.jpg", "TestFiles.fire-umbrella-small.jpg"))
{
// set clock to present, and build date to far future
var clock = new FakeClock("2017-04-25", "2022-01-01");
foreach (var set in LicenseStrings.GetSets("CancelledImageflow", "SoftRevocationImageflow",
"HardRevocationImageflow"))
{
output.WriteLine($"Testing revocation for {set.Name}");
var mgr = new LicenseManagerSingleton(ImazenPublicKeys.Test, clock, new StringCacheMem());
MockHttpHelpers.MockRemoteLicense(mgr, HttpStatusCode.OK, set.Remote, null);
var url = new RequestUrlProvider();
var licensing = new Licensing(mgr, url.Get);
using var host = await StartAsyncWithOptions(new ImageflowMiddlewareOptions ()
{
Licensing = licensing,
MyOpenSourceProjectUrl = null
}
.SetLicenseKey (EnforceLicenseWith.Http402Error,
set.Placeholder)
.MapPath("/", Path.Combine(contentRoot.PhysicalPath, "images")));
// Create an HttpClient to send requests to the TestServer
using var client = host.GetTestClient();
mgr.WaitForTasks();
url.Url = new Uri("https://domain.com");
using var notLicensedResponse = await client.GetAsync("/fire.jpg?w=1");
Assert.Equal(HttpStatusCode.PaymentRequired, notLicensedResponse.StatusCode);
url.Url = null;
using var notLicensedResponse2 = await client.GetAsync("/fire.jpg?w=1");
Assert.Equal(HttpStatusCode.PaymentRequired, notLicensedResponse2.StatusCode);
Assert.NotEmpty(mgr.GetIssues());
var page = licensing.Result.ProvidePublicLicensesPage();
Assert.Contains("License Validation ON", page);
Assert.Contains("You are using EnforceLicenseWith.Http402Error", page);
Assert.Contains("No valid license keys found.", page);
Assert.Contains(
"Your license is invalid. Please renew your license via the management portal or purchase a new one at",
page);
Assert.DoesNotContain("Your license needs to be upgraded.", page);
if (set.Name == "CancelledImageflow")
{
Assert.Contains("Your subscription has lapsed; please renew to continue using product.", page);
}
if (set.Name == "SoftRevocationImageflow")
{
Assert.Contains(
"This license has been compromised; please contact Vendor Gamma for an updated license",
page);
}
if (set.Name == "HardRevocationImageflow")
{
Assert.Contains(
"Please contact support; the license was shared with an unauthorized party and has been revoked.",
page);
}
await host.StopAsync(CancellationToken.None);
}
}
}
public async void TestDomainsLicense()
{
using (var contentRoot = new TempContentRoot()
.AddResource("images/fire.jpg", "TestFiles.fire-umbrella-small.jpg"))
{
var clock = new FakeClock("2017-04-25", "2017-04-25");
var set = LicenseStrings.GetSets("PerCore2DomainsImageflow").First();
var mgr = new LicenseManagerSingleton(ImazenPublicKeys.Test, clock, new StringCacheMem());
MockHttpHelpers.MockRemoteLicense(mgr, HttpStatusCode.OK, set.Remote, null);
var url = new RequestUrlProvider();
var licensing = new Licensing(mgr, url.Get);
using var host = await StartAsyncWithOptions(new ImageflowMiddlewareOptions ()
{
Licensing = licensing,
MyOpenSourceProjectUrl = null
}
.SetLicenseKey (EnforceLicenseWith.Http402Error,
set.Placeholder)
.MapPath("/", Path.Combine(contentRoot.PhysicalPath, "images")));
// Create an HttpClient to send requests to the TestServer
using var client = host.GetTestClient();
mgr.WaitForTasks();
Assert.Empty(mgr.GetIssues());
url.Url = new Uri("https://unlicenseddomain.com");
using var notLicensedResponse = await client.GetAsync("/fire.jpg?w=1");
Assert.Equal(HttpStatusCode.PaymentRequired, notLicensedResponse.StatusCode);
url.Url = new Uri("https://acme.com");
using var licensedResponse1 = await client.GetAsync("/fire.jpg?w=1");
licensedResponse1.EnsureSuccessStatusCode();
url.Url = new Uri("https://acmestaging.com");
using var licensedResponse2 = await client.GetAsync("/fire.jpg?w=1");
licensedResponse2.EnsureSuccessStatusCode();
url.Url = new Uri("https://subdomain.acme.com");
using var licensedResponse3 = await client.GetAsync("/fire.jpg?w=1");
licensedResponse3.EnsureSuccessStatusCode();
Assert.Empty(mgr.GetIssues());
var page = licensing.Result.ProvidePublicLicensesPage();
Assert.Contains("License Validation ON", page);
Assert.DoesNotContain("No license keys found.", page);
Assert.Contains("License valid for 2 domains, missing for 1 domains", page);
Assert.Contains("Your license needs to be upgraded", page);
Assert.Contains("You are using EnforceLicenseWith.Http402Error", page);
await host.StopAsync(CancellationToken.None);
}
}
public ImageflowMiddleware(
RequestDelegate next,
IWebHostEnvironment env,
IEnumerable <ILogger <ImageflowMiddleware> > logger,
IEnumerable <IClassicDiskCache> diskCaches,
IEnumerable <IStreamCache> streamCaches,
IEnumerable <IBlobProvider> blobProviders,
ImageflowMiddlewareOptions options)
{
this.next = next;
options.Licensing ??= new Licensing(LicenseManagerSingleton.GetOrCreateSingleton(
"imageflow_", new[] { env.ContentRootPath, Path.GetTempPath() }));
this.options = options;
this.env = env;
this.logger = logger.FirstOrDefault();
diskCache = diskCaches.FirstOrDefault();
var streamCacheArray = streamCaches.ToArray();
if (streamCacheArray.Count() > 1)
{
throw new InvalidOperationException("Only 1 IStreamCache instance can be registered at a time");
}
streamCache = streamCacheArray.FirstOrDefault();
var providers = blobProviders.ToList();
var mappedPaths = options.MappedPaths.ToList();
if (options.MapWebRoot)
{
if (this.env?.WebRootPath == null)
{
throw new InvalidOperationException("Cannot call MapWebRoot if env.WebRootPath is null");
}
mappedPaths.Add(new PathMapping("/", this.env.WebRootPath));
}
//Determine the active cache backend
var streamCacheEnabled = streamCache != null && options.AllowCaching;
var diskCacheEnabled = this.diskCache != null && options.AllowDiskCaching;
if (streamCacheEnabled)
{
options.ActiveCacheBackend = CacheBackend.StreamCache;
}
else if (diskCacheEnabled)
{
options.ActiveCacheBackend = CacheBackend.ClassicDiskCache;
}
else
{
options.ActiveCacheBackend = CacheBackend.NoCache;
}
options.Licensing.Initialize(this.options);
blobProvider = new BlobProvider(providers, mappedPaths);
diagnosticsPage = new DiagnosticsPage(options, env, this.logger, streamCache, this.diskCache, providers);
licensePage = new LicensePage(options);
globalInfoProvider = new GlobalInfoProvider(options, env, this.logger, streamCache, this.diskCache, providers);
options.Licensing.FireHeartbeat();
GlobalPerf.Singleton.SetInfoProviders(new List <IInfoProvider>()
{
globalInfoProvider
});
}
public void Test_Caching_With_Write_Delay()
{
if (Environment.GetEnvironmentVariable("APPVEYOR") == "True")
{
return;
}
var clock = new OffsetClock("2017-04-25", "2017-04-25");
var cache = new StringCacheMem();
// Populate cache
{
var mgr = new LicenseManagerSingleton(ImazenPublicKeys.Test, clock)
{
Cache = cache
};
MockHttpHelpers.MockRemoteLicense(mgr, HttpStatusCode.OK, LicenseStrings.EliteSubscriptionRemote,
null);
var conf = new Config();
conf.Plugins.LicenseScope = LicenseAccess.Local;
conf.Plugins.Install(new LicensedPlugin(mgr, clock, "R_Elite", "R4Elite"));
conf.Plugins.AddLicense(LicenseStrings.EliteSubscriptionPlaceholder);
Assert.Equal(1, mgr.WaitForTasks());
var result = new Computation(conf, ImazenPublicKeys.Test, mgr, mgr, clock, true);
Assert.True(result.LicensedForRequestUrl(new Uri("http://anydomain")));
Assert.Empty(mgr.GetIssues());
Assert.NotNull(conf.GetLicensesPage());
}
// Use cache
{
var mgr = new LicenseManagerSingleton(ImazenPublicKeys.Test, clock)
{
Cache = cache
};
var conf = new Config();
conf.Plugins.LicenseScope = LicenseAccess.Local;
conf.Plugins.Install(new LicensedPlugin(mgr, clock, "R_Elite", "R4Elite"));
conf.Plugins.AddLicense(LicenseStrings.EliteSubscriptionPlaceholder);
mgr.Heartbeat();
Assert.Equal(0, mgr.WaitForTasks());
var result = new Computation(conf, ImazenPublicKeys.Test, mgr, mgr, clock, true);
Assert.True(result.LicensedForRequestUrl(new Uri("http://anydomain")));
Assert.NotNull(conf.GetDiagnosticsPage());
Assert.NotNull(conf.GetLicensesPage());
Assert.Equal(0, mgr.GetIssues().Count());
MockHttpHelpers.MockRemoteLicenseException(mgr, WebExceptionStatus.NameResolutionFailure);
while (!mgr.AllowFetching())
{
mgr.Heartbeat();
}
mgr.WaitForTasks();
result = new Computation(conf, ImazenPublicKeys.Test, mgr, mgr, clock, true);
Assert.True(result.LicensedForRequestUrl(new Uri("http://anydomain")));
Assert.Equal(1, mgr.GetIssues().Count());
}
}