public static String GetSanitizedName(String fullName)
{
const Int32 maxLength = 51;
StringBuilder sanitizedBuilder = fullName.Aggregate(new StringBuilder(),
(SB, c) => isAllowedCharacter(c)
? SB.Append(c)
: SB.Append('!').Append(((Int32)c).ToString("x4")));
String sanitizedString = sanitizedBuilder.ToString();
if (sanitizedString.Length <= maxLength)
{
return(sanitizedString);
}
String testForIncompleteSequence = sanitizedString.Substring(maxLength - 4, 4);
Int32 i = testForIncompleteSequence.IndexOf('!');
Int32 splitPosition = i < 0
? maxLength
: maxLength - 4 + i;
String exceeded = sanitizedString.Substring(splitPosition);
String truncated = sanitizedString.Remove(splitPosition);
return(truncated + "-" + getExceedHash(exceeded));
}
//---------------------------------------------------------------------
// 初始化MasteSlave
async Task IGrainDCache.initMasteSlave(string maste_name)
{
var grain_master = this.GrainFactory.GetGrain <IGrainDCacheMaster>(maste_name);
bool is_inited = await grain_master.GetIfInit();
if (is_inited)
{
return;
}
grain_master.Init();
grain_master.setup(maste_name, DCacheMasterSlaveMaxDeep, DCacheMasterSlaveCount);
for (int i = 1; i <= DCacheMasterSlaveCount; i++)
{
SB.Clear();
SB.Append(maste_name);
SB.Append("_");
SB.Append(SLAVE_MAP_NAME);
SB.Append("_");
SB.Append(SLAVE_ROOT_DEEP);
SB.Append("_");
SB.Append(i);
var grain_slave = this.GrainFactory.GetGrain <IGrainDCacheSlave>(SB.ToString());
grain_slave.setup(maste_name, SLAVE_ROOT_DEEP, DCacheMasterSlaveMaxDeep, DCacheMasterSlaveCount);
}
}
//---------------------------------------------------------------------
// Count Cache
async Task <int> IGrainDCacheMapCounter.countMap()
{
ListCountTask.Clear();
for (int i = 1; i <= MapCount; i++)
{
SB.Clear();
SB.Append(KeyTitle);
SB.Append("_");
SB.Append(i);
var grain_map = this.GrainFactory.GetGrain <IGrainDCacheMap>(SB.ToString());
ListCountTask.Add(grain_map.getMapCount());
}
await Task.WhenAll(ListCountTask);
MapCacheDataCount = 0;
foreach (var i in ListCountTask)
{
if (i.IsCompleted)
{
MapCacheDataCount += ((Task <int>)i).Result;
}
}
ListCountTask.Clear();
return(MapCacheDataCount);
}
private void GerarMetodos(Service service)
{
foreach (var metodo in service.Metodos)
{
SB.Append($"\t{metodo.Nome} = (");
for (var i = 0; i < metodo.Parametros.Count; i++)
{
var param = metodo.Parametros[i];
SB.Append($"{param.Nome}: {param.Tipo}");
if (i + 1 < metodo.Parametros.Count)
{
SB.Append(", ");
}
}
SB.AppendLine(") =>");
var rota = metodo.Rota.Replace("[action]", metodo.Nome);
SB.Append($"\t\tthis.CreateRequest<{metodo.Retorno}>(RequestType.{metodo.Tipo}, `{rota}`");
var bodyParams = metodo.Parametros.Where(x => !x.IsQueryString).ToList();
if (bodyParams.Count > 0)
{
SB.Append($", ");
if (bodyParams.Count == 1)
{
SB.Append(metodo.Parametros[0].Nome);
}
else
{
SB.Append("{ ");
for (var i = 0; i < bodyParams.Count; i++)
{
SB.Append(bodyParams[i].Nome);
if (i + 1 < bodyParams.Count)
{
SB.Append(", ");
}
}
SB.Append("}");
}
}
else
{
if (!string.IsNullOrEmpty(metodo.Resposta) && metodo.Resposta != TipoResposta.Normal.ToDescriptionString())
{
SB.Append($", null, ResponseType.{metodo.Resposta}");
}
}
SB.AppendLine(");");
SB.AppendLine();
}
}
//---------------------------------------------------------------------
// Count 所有MapCache
async Task <int> IGrainDCache.countMap(string map_name)
{
SB.Clear();
SB.Append(map_name);
SB.Append("_");
SB.Append(DCACHEMAP_COUNTER_TITLE);
var grain_mapcounter = this.GrainFactory.GetGrain <IGrainDCacheMapCounter>(SB.ToString());
int count = await grain_mapcounter.countMap();
return(count);
}
//---------------------------------------------------------------------
public string AppendStrWithSB(params string[] strs)
{
ClearSB();
foreach (var i in strs)
{
SB.Append(i);
}
return(SB.ToString());
}
private void AddRecipeLinks(IRecipe[] recipes)
{
SB.Append("<div style='margin-left: 1em;'>");
foreach (IRecipe recipe in recipes)
{
string categoryPageName = $"{Sanitize(recipe.Category)}{ExtPage}";
string recipeUrl = $"{categoryPageName}#{recipe.ID}".ToLower();
SB.AppendLine($"<p><a href='{recipeUrl}' style='font-weight: 600;'>{recipe.Title}</a> - {recipe.Description}</p>");
}
SB.Append("</div>");
}
public void Scan()
{
char c = C();
SB.Append(c);
Queue.Enqueue(c);
if (Queue.Count > Length)
{
Queue.Dequeue();
}
}
//---------------------------------------------------------------------
// 从Map中随机获取数据
async Task <List <byte[]> > IGrainDCache.getFromMapRandom(string map_name, int count)
{
int map_index = Random.Next(1, DCacheMapCount + 1);
SB.Clear();
SB.Append(map_name);
SB.Append("_");
SB.Append(map_index);
var grain_map = this.GrainFactory.GetGrain <IGrainDCacheMap>(SB.ToString());
var list_value = await grain_map.getFromMapRandom(count);
return(list_value);
}
//---------------------------------------------------------------------
// add数据到Map中
async Task <string> IGrainDCache.addToMap(string map_name, string ticket, string key, byte[] value)
{
if (string.IsNullOrEmpty(ticket))
{
int map_index = Random.Next(1, DCacheMapCount + 1);
SB.Clear();
SB.Append(map_name);
SB.Append("_");
SB.Append(map_index);
ticket = SB.ToString();
}
var grain_map = this.GrainFactory.GetGrain <IGrainDCacheMap>(ticket);
var tick = await grain_map.addToMap(key, value);
return(tick);
}
//---------------------------------------------------------------------
// 从MasteSlave中获取数据
async Task <byte[]> IGrainDCache.getFromMasteSlave(string maste_name, string key)
{
int slave_count = (int)Math.Pow(DCacheMasterSlaveCount, DCacheMasterSlaveMaxDeep - 1);
int slave_index = Random.Next(1, slave_count + 1);
SB.Clear();
SB.Append(maste_name);
SB.Append("_");
SB.Append(SLAVE_MAP_NAME);
SB.Append("_");
SB.Append(DCacheMasterSlaveMaxDeep);
SB.Append("_");
SB.Append(slave_index);
var grain_slave = this.GrainFactory.GetGrain <IGrainDCacheSlave>(SB.ToString());
var result = await grain_slave.getFromSlave(key);
return(result);
}
//---------------------------------------------------------------------
// add数据到MasteSlave中
Task IGrainDCacheMaster.addToMasteSlave(string key, byte[] value)
{
MapCache[key] = value;
for (int i = 1; i <= SlaveCount; i++)
{
SB.Clear();
SB.Append(MasterName);
SB.Append("_");
SB.Append(GrainDCache.SLAVE_MAP_NAME);
SB.Append("_");
SB.Append(GrainDCache.SLAVE_ROOT_DEEP);
SB.Append("_");
SB.Append(i);
var grain_slave = this.GrainFactory.GetGrain <IGrainDCacheSlave>(SB.ToString());
grain_slave.addToSlave(key, value);
}
return(TaskDone.Done);
}
/// <summary>
/// Verify HWID matches license key
/// </summary>
/// <param name="HWID"></param>
/// <param name="licenseKey"></param>
/// <returns></returns>
private bool verifyHWID(string HWID, string licenseKey)
{
// Seperate first 8 digits as HWID
string KeyHWIDHash = licenseKey.Split('-')[0] + licenseKey.Split('-')[1];
// Get hash of hwid
string HWIDHash;
using (System.Security.Cryptography.MD5 md5 = System.Security.Cryptography.MD5.Create())
{
// Split HWID into bytes
byte[] inputBytes = System.Text.Encoding.UTF8.GetBytes(HWID);
// Hash bytes
byte[] hashBytes = md5.ComputeHash(inputBytes);
// Convert to hexidecimal string
HWIDHash = hashBytes.Aggregate(new StringBuilder(), (SB, hb) => SB.Append(hb.ToString("x2"))).ToString();
}
// convert hexidecimal hash to integer
BigInteger HWIDHashInt = BigInteger.Parse(HWIDHash, System.Globalization.NumberStyles.HexNumber);
// mod integer to 8 hex digits
HWIDHashInt = (BigInteger)(HWIDHashInt % (BigInteger)(Math.Pow(2, 4 * 8)));
// convert int back to hex
HWIDHash = HWIDHashInt.ToString("X");
// trim leading characters
while (HWIDHash.Length > 8)
{
HWIDHash = HWIDHash.Substring(1);
}
// Return hash equivalency
return(HWIDHash.CompareTo(KeyHWIDHash) == 0);
}
//---------------------------------------------------------------------
// remove数据
Task IGrainDCacheMaster.removeFromMasteSlave(string key)
{
if (MapCache.ContainsKey(key))
{
MapCache.Remove(key);
}
for (int i = 1; i <= SlaveCount; i++)
{
SB.Clear();
SB.Append(MasterName);
SB.Append("_");
SB.Append(GrainDCache.SLAVE_MAP_NAME);
SB.Append("_");
SB.Append(GrainDCache.SLAVE_ROOT_DEEP);
SB.Append("_");
SB.Append(i);
var grain_slave = this.GrainFactory.GetGrain <IGrainDCacheSlave>(SB.ToString());
grain_slave.removeFromSlave(key);
}
return(TaskDone.Done);
}
//---------------------------------------------------------------------
// 初始化Map
async Task IGrainDCache.initMap(string map_name)
{
int count = DCacheMapCount;
int map_index = Random.Next(1, count + 1);
SB.Clear();
SB.Append(map_name);
SB.Append("_");
SB.Append(map_index);
var grain_maprandom = this.GrainFactory.GetGrain <IGrainDCacheMap>(SB.ToString());
var is_inited = await grain_maprandom.GetIfInit();
if (is_inited)
{
return;
}
SB.Clear();
SB.Append(map_name);
SB.Append("_");
SB.Append(DCACHEMAP_COUNTER_TITLE);
var grain_mapcounter = this.GrainFactory.GetGrain <IGrainDCacheMapCounter>(SB.ToString());
grain_mapcounter.setup(map_name, count);
for (int i = 1; i <= count; i++)
{
SB.Clear();
SB.Append(map_name);
SB.Append("_");
SB.Append(i);
var grain_map = this.GrainFactory.GetGrain <IGrainDCacheMap>(SB.ToString());
grain_map.setup();
}
}
protected override void StartToken(LesColorCode kind)
{
SB.Append((char)kind);
}
public GremlinScript Append(string Script)
{
SB.Append(Script);
return(this);
}
