private static WhoisEnhancedRecord WhoisEnhanced(string ipAddress, string filters, string referrer)
{
if (filters != null)
{
filters = filters.Scrub();
Assert.ValidInput(filters, "filters");
}
if (referrer != null)
{
referrer = referrer.Scrub();
Assert.ValidInput(referrer, "referrer");
}
var hash = BuildHashKey(ipAddress, filters);
if (ServiceCache.IsInCache <WhoisEnhancedRecord>(hash))
{
var cachedRecord = (WhoisEnhancedRecord)ServiceCache.GetFromCache <WhoisEnhancedRecord>(hash);
if (cachedRecord != null)
{
return(cachedRecord);
}
}
var whoisEnhancedRecord = new WhoisEnhancedRecord(Whois(ipAddress), filters, referrer);
return(whoisEnhancedRecord.AddToCache(hash));
}
public ControllerBase([CreateNew] IController parent)
{
Parent = parent;
Controllers = new ControllerCache(parent);
Services = new ServiceCache(parent);
Views = new ViewCache(parent);
}
private static WhoisRecord Whois(string ipAddress)
{
ipAddress = ipAddress.Scrub();
if (string.IsNullOrEmpty(ipAddress))
{
ipAddress = GetIpAddressFromRequest(ipAddress);
}
Assert.ValidInput(ipAddress, "ipAddress");
if (ServiceCache.IsInCache <WhoisRecord>(ipAddress))
{
var cachedRecord = (WhoisRecord)ServiceCache.GetFromCache <WhoisRecord>(ipAddress);
if (cachedRecord != null)
{
return(cachedRecord);
}
}
var whoisClient = new WhoisClient(ipAddress);
var record = whoisClient.GetWhoisRecord();
HandleErrors(whoisClient.Errors);
return(record.AddToCache(ipAddress));
}
private static Resume Resume(string firstnameLastname)
{
Assert.ValidInput(firstnameLastname, "firstname-lastname");
firstnameLastname = firstnameLastname.Scrub();
if (ServiceCache.IsInCache <Resume>(firstnameLastname))
{
var cachedResume = (Resume)ServiceCache.GetFromCache <Resume>(firstnameLastname);
if (cachedResume != null)
{
return(cachedResume);
}
}
var linkedInEmailAddress = ConfigurationManager.AppSettings["LinkedInEmailAddress"];
var linkedInPassword = ConfigurationManager.AppSettings["LinkedInPassword"];
var resumeSniffer = new LinkedInResumeSniffer(linkedInEmailAddress, linkedInPassword, firstnameLastname);
Resume resume = null;
try
{
resume = resumeSniffer.GetResume();
}
catch (Exception)
{
HandleErrors(linkedInEmailAddress);
}
HandleErrors(resumeSniffer.Errors);
return(resume.AddToCache(firstnameLastname));
}
public Client(NetworkInterface networkInterface)
{
network_interface_info = NetworkInterfaceInfo.GetNetworkInterfaceInfo(networkInterface);
service_cache = new ServiceCache(this);
notify_listener = new NotifyListener(this);
browsers = new Dictionary <string, Browser> ();
}
public IEnumerable <ServiceCache> GetServiceCaches()
{
var cacheWrapperSetting = AppConfig.Configuration.Get <CachingProvider>();
var bingingSettings = cacheWrapperSetting.CachingSettings;
var serviceCaches = new List <ServiceCache>();
foreach (var setting in bingingSettings)
{
var context = _serviceProvider.GetInstances <RedisContext>(setting.Id);
foreach (var type in context.dicHash.Keys)
{
var cacheDescriptor = new CacheDescriptor
{
Id = $"{setting.Id}.{type.ToString()}",
Prefix = setting.Id,
Type = type
};
int.TryParse(context.DefaultExpireTime, out int defaultExpireTime);
int.TryParse(context.ConnectTimeout, out int connectTimeout);
cacheDescriptor.DefaultExpireTime(defaultExpireTime);
cacheDescriptor.ConnectTimeout(connectTimeout);
var serviceCache = new ServiceCache
{
CacheDescriptor = cacheDescriptor,
CacheEndpoint = context.dicHash[type].GetNodes()
};
serviceCaches.Add(serviceCache);
}
}
return(serviceCaches);
}
private void SaveConfiguration(ServiceCache cache)
{
if (this.queue.Count > 0)
{
this.queue.Dequeue();
}
var setting = _cachingProvider.CachingSettings.Where(p => p.Id == cache.CacheDescriptor.Prefix).FirstOrDefault();
setting.Properties.ForEach(p =>
{
if (p.Maps != null)
{
p.Maps.ForEach(m =>
{
if (m.Name == cache.CacheDescriptor.Type)
{
m.Properties = cache.CacheEndpoint.Select(n =>
{
var hashNode = n as ConsistentHashNode;
return(new Property
{
Value = $"{hashNode.Host}:{hashNode.Port}::{hashNode.Db}"
});
}).ToList();
}
});
}
});
this.queue.Enqueue(true);
}
public void OneRecordRefreshed()
{
var name = "scooby.doo.local";
var recordType = 1;
var ttl = 1;
var timer = new Mock <ITimer>();
var serviceCache = new ServiceCache(timer.Object);
var packet = CreatePacket(new[] { new Tuple <string, int, int>(name, recordType, ttl) });
var verified = true;
serviceCache.AddPacket(packet);
serviceCache.RequestUpdate += (x) =>
{
if (x.Length != 0)
{
verified = false;
}
};
Thread.Sleep(1000);
var packet2 = CreatePacket(new[] { new Tuple <string, int, int>(name, recordType, ttl * 10) });
serviceCache.AddPacket(packet2);
timer.Raise(x => x.Fired += null);
Assert.IsTrue(verified);
}
public void ShouldTestThatKeyUsesObjectName()
{
var hash = ServiceCache.Hash <MyTestObject>("dude");
Assert.IsTrue(hash.Contains("MyTestObject"));
Assert.IsTrue(hash.Contains("dude"));
Console.Write(hash);
}
private static T GetFromCache <T>(string key)
{
if (ServiceCache.IsInCache <T>(key))
{
return((T)ServiceCache.GetFromCache <T>(key));
}
return(default(T));
}
/// <summary>
/// 添加自定义的Repository服务，完成dbcontext的注入，Repository的注入
/// </summary>
/// <param name="services"></param>
/// <param name="action"></param>
public static void AddCache(this IServiceCollection services, Action <OptionsCache> action)
{
OptionsCache options = new OptionsCache();
action.Invoke(options);
ServiceCache srv = new ServiceCache(services, options);
srv.LoadCache();
}
public void OnConnection(object application, ext_ConnectMode connectMode, object addInInst, ref Array custom)
{
addInInstance = (AddIn)addInInst;
applicationObject = (DTE2)addInInstance.DTE;
switch (connectMode)
{
case ext_ConnectMode.ext_cm_Startup:
Commands2 commands = (Commands2)applicationObject.Commands;
CommandBar menuBarCommandBar = ((CommandBars)applicationObject.CommandBars)["MenuBar"];
CommandBar standardCommandBar = ((CommandBars)applicationObject.CommandBars)["Standard"];
this.openViewerButton = AddCommandBarButton(commands,
standardCommandBar,
"OpenInternalsViewer",
"Open Internals Viewer",
Properties.Resources.allocationMapIcon,
Properties.Resources.allocationMapIconMask);
CommandBarPopup commandBarPopup = (CommandBarPopup)menuBarCommandBar.Controls.Add(MsoControlType.msoControlPopup,
System.Type.Missing,
System.Type.Missing,
8,
Properties.Resources.AppWindow);
commandBarPopup.Caption = "Internals Viewer";
AddCommandBarPopup(commands,
commandBarPopup,
"AllocationMap",
"Allocation Map",
"Show the Allocation Map",
Properties.Resources.allocationMapIcon,
Properties.Resources.allocationMapIconMask);
AddCommandBarPopup(commands,
commandBarPopup,
"TransactionLog",
"Display Transaction Log",
"Include the Transaction Log with query results",
Properties.Resources.TransactionLogIcon,
Properties.Resources.allocationMapIconMask);
IObjectExplorerEventProvider provider = ServiceCache.GetObjectExplorer().GetService(typeof(IObjectExplorerEventProvider)) as IObjectExplorerEventProvider;
provider.NodesRefreshed += new NodesChangedEventHandler(Provider_NodesRefreshed);
provider.NodesAdded += new NodesChangedEventHandler(Provider_NodesRefreshed);
provider.BufferedNodesAdded += new NodesChangedEventHandler(Provider_NodesRefreshed);
this.windowManager = new WindowManager(applicationObject, addInInstance);
this.queryEditorExtender = new QueryEditorExtender(applicationObject, this.windowManager);
break;
}
}
public void CanRegisterService()
{
var cache = new ServiceCache();
cache.Register(new ServiceIdentity {
ServiceName = "test", Location = "/"
});
Assert.Equal(1, cache.Keys.Count);
}
/// <summary>
/// Gets the object explorer selected nodes.
/// </summary>
/// <returns></returns>
private INodeInformation[] GetObjectExplorerSelectedNodes()
{
IObjectExplorerService objExplorer = ServiceCache.GetObjectExplorer();
int arraySize;
INodeInformation[] nodes;
objExplorer.GetSelectedNodes(out arraySize, out nodes);
return(nodes);
}
public ServicesController()
{
_services = new ServiceCache();
_services.Register(new ServiceIdentity {
ServiceName = "positions"
});
_services.Register(new ServiceIdentity {
ServiceName = "exposures"
});
}
public void RegisterAssignsInstanceKey()
{
var service = new ServiceIdentity {
ServiceName = "FOO"
};
var cache = new ServiceCache();
cache.Register(service);
Assert.NotEmpty(service.InstanceKey);
}
private async Task <ServiceCache> GetCache(string path)
{
ServiceCache result = null;
var watcher = new NodeMonitorWatcher(_zooKeeper, path,
async(oldData, newData) => await NodeChange(oldData, newData));
if (await _zooKeeper.existsAsync(path) != null)
{
var data = (await _zooKeeper.getDataAsync(path, watcher)).Data;
watcher.SetCurrentData(data);
result = await GetCache(data);
}
return(result);
}
public async Task <List <MicroService> > GetAsync([NotNull] string service, CancellationToken cancellationToken = default)
{
Check.NotNullOrWhiteSpace(service, nameof(service));
var key = GetCacheKey();
var services = await ServiceCache.GetAsync(key, token : cancellationToken);
if (services == null)
{
await Poll();
}
services = await ServiceCache.GetAsync(key);
return(services);
}
/// <summary>
/// Gets the object explorer tree view.
/// </summary>
/// <returns></returns>
private TreeView GetObjectExplorerTreeView()
{
Type t = ServiceCache.GetObjectExplorer().GetType();
FieldInfo field = t.GetField("tree", BindingFlags.NonPublic | BindingFlags.Instance);
if (field != null)
{
return((TreeView)field.GetValue(ServiceCache.GetObjectExplorer()));
}
else
{
return(null);
}
}
private async Task Poll()
{
var services = await ConsulDiscoveryService.GetAsync(Option.Service);
if (services == null)
{
services = new List <MicroService>();
}
var key = GetCacheKey();
await ServiceCache.SetAsync(key, services, new DistributedCacheEntryOptions()
{
AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(Option.Expires)
});
}
public static void Dispose()
{
if (instance != null)
{
ServiceCache.EventBus.StopCurrentEventPropagation();
instance.container.Dispose();
ServiceCache.Dispose();
instance.servicesRegistered.Clear();
instance.servicesLoaded.Clear();
instance = null;
OnDisposed();
OnDisposed = delegate { };
}
}
private async Task <IEnumerable <ServiceInformation> > GetServicesAsync(string name, string version)
{
if (_serviceCache.TryGetValue(name, out ServiceCache serviceCache))
{
if (serviceCache.RefreshTime > DateTime.Now)
{
return(serviceCache.Services);
}
}
var services = await _serviceDiscovery.GetServicesAsync(name, version);
var newCache = new ServiceCache(name, DateTime.Now.AddSeconds(_options.CacheRefreshInterval), services);
_serviceCache.AddOrUpdate(name, newCache, (key, oldCache) => { return(newCache); });
return(services);
}
private async Task <ServiceCache> GetCache(string path)
{
ServiceCache result = null;
var watcher = new NodeMonitorWatcher(_consul, _manager, path,
async(oldData, newData) => await NodeChange(oldData, newData));
var queryResult = await _consul.KV.Keys(path);
if (queryResult.Response != null)
{
var data = (await _consul.GetDataAsync(path));
if (data != null)
{
watcher.SetCurrentData(data);
result = await GetCache(data);
}
}
return(result);
}
private void SaveConfiguration(ServiceCache cache)
{
if (queue.Count > 0)
{
queue.Dequeue();
}
var setting = _cachingProvider.CachingSettings.Where(p => p.Id == cache.CacheDescriptor.Prefix)
.FirstOrDefault();
if (setting != null)
{
setting.Properties.ForEach(p =>
{
if (p.Maps != null)
{
p.Maps.ForEach(m =>
{
if (m.Name == cache.CacheDescriptor.Type)
{
m.Properties = cache.CacheEndpoint.Select(n =>
{
var hashNode = n as ConsistentHashNode;
if (!string.IsNullOrEmpty(hashNode.UserName) ||
!string.IsNullOrEmpty(hashNode.Password))
{
return(new Property
{
Value =
$"{hashNode.UserName}:{hashNode.Password}@{hashNode.Host}:{hashNode.Port}::{hashNode.Db}"
});
}
return(new Property
{
Value = $"{hashNode.Host}:{hashNode.Port}::{hashNode.Db}"
});
}).ToList();
}
});
}
});
queue.Enqueue(true);
}
}
private static Reviews Reviews(string customerId)
{
Assert.ValidInput(customerId, "customerId");
if (ServiceCache.IsInCache <Reviews>(customerId))
{
var cachedReviews = (Reviews)ServiceCache.GetFromCache <Reviews>(customerId);
if (cachedReviews != null)
{
return(cachedReviews);
}
}
var amazonResponse = new AmazonFactory(BuildRequest(customerId, null)).GetResponse();
HandleErrors(amazonResponse.Errors);
return(new Reviews(amazonResponse.Reviews.OrderByDescending(r => r.Date)).AddToCache(customerId));
}
private static Wishlist Wishlist(string listId)
{
Assert.ValidInput(listId, "listId");
if (ServiceCache.IsInCache <Wishlist>(listId))
{
var cachedWishlist = (Wishlist)ServiceCache.GetFromCache <Wishlist>(listId);
if (cachedWishlist != null)
{
return(cachedWishlist);
}
}
var amazonResponse = new AmazonFactory(BuildRequest(null, listId)).GetResponse();
HandleErrors(amazonResponse.Errors);
return(new Wishlist(amazonResponse.Products.OrderBy(p => p.AuthorsMLA).ThenBy(p => p.Title)).AddToCache(listId));
}
public async Task DelCacheEndpointAsync(string cacheId, string endpoint)
{
var model = await ServiceLocator.GetService <IServiceCacheManager>().GetAsync(cacheId);
var cacheEndpoints = model.CacheEndpoint.Where(p => p.ToString() != endpoint).ToList();
model.CacheEndpoint = cacheEndpoints;
var caches = new ServiceCache[] { model };
var descriptors = caches.Where(cache => cache != null).Select(cache => new ServiceCacheDescriptor
{
AddressDescriptors = cache.CacheEndpoint?.Select(address => new CacheEndpointDescriptor
{
Type = address.GetType().FullName,
Value = _serializer.Serialize(address)
}) ?? Enumerable.Empty <CacheEndpointDescriptor>(),
CacheDescriptor = cache.CacheDescriptor
});
await ServiceLocator.GetService <IServiceCacheManager>().SetCachesAsync(descriptors);
}
private async Task <ServiceCache> GetCache(string path)
{
ServiceCache result = null;
var zooKeeperClient = await _zookeeperClientProvider.GetZooKeeperClient();
if (zooKeeperClient == null)
{
return(result);
}
if (await zooKeeperClient.ExistsAsync(path))
{
var data = (await zooKeeperClient.GetDataAsync(path)).ToArray();
var watcher = nodeWatchers.GetOrAdd(path, f => new NodeMonitorWatcher(path, async(oldData, newData) => await NodeChange(oldData, newData)));
await zooKeeperClient.SubscribeDataChange(path, watcher.HandleNodeDataChange);
result = await GetCache(data);
}
return(result);
}
public async Task ServiceHasCacheTest()
{
var cache = new ServiceCache();
var service = new Management(MockData.ServiceNowUrl, MockData.Token, MockData.LimitSize, MockData.ServiceNowGetUserId, cache, mockClient);
var result = await service.CountKnowledge(MockData.KnowledgeTitle);
Assert.AreEqual(result.Success, true);
Assert.AreEqual(result.Knowledges.Length, MockData.KnowledgeCount);
Assert.AreEqual(mockServiceNowRestClient.GetUserIdResponseCount, 1);
service = new Management(MockData.ServiceNowUrl, MockData.Token, MockData.LimitSize, MockData.ServiceNowGetUserId, cache, mockClient);
result = await service.CountKnowledge(MockData.KnowledgeTitle);
Assert.AreEqual(result.Success, true);
Assert.AreEqual(result.Knowledges.Length, MockData.KnowledgeCount);
Assert.AreEqual(mockServiceNowRestClient.GetUserIdResponseCount, 1);
}
public Context(IFileSystem?fs = null)
{
Filesystem = fs ?? Substitute.For <IFileSystem>();
StoragePath = Substitute.For <ICacheStoragePath>();
ConfigProvider = Substitute.For <IConfigurationProvider>();
JsonSettings = new JsonSerializerSettings
{
Formatting = Formatting.Indented,
ContractResolver = new DefaultContractResolver
{
NamingStrategy = new SnakeCaseNamingStrategy()
}
};
// Set up a default for the active config's base URL. This is used to generate part of the path
ConfigProvider.ActiveConfiguration = Substitute.For <IServiceConfiguration>();
ConfigProvider.ActiveConfiguration.BaseUrl.Returns("http://localhost:1234");
Cache = new ServiceCache(Filesystem, StoragePath, ConfigProvider, Substitute.For <ILogger>());
}
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);
}
}
}
