public void Refresh()
{
if (Provider != null)
{
_config = Provider.ReadConfig();
}
}
private static void SetFileInfo(KeyValueConfig config, string type, string hash, EncodingFile encoding)
{
if (!MD5Hash.TryParse(hash, out var ekey))
{
return;
}
if (!encoding.TryGetEKeyEntry(ekey, out var encodedEntry))
{
return;
}
var contentEntry = encoding.GetCKeyEntryByEKey(ekey);
if (contentEntry == null)
{
return;
}
config.SetValue(type, contentEntry.CKey, 0);
if (type != "root")
{
config.SetValue(type, hash, 1);
config.SetValue(type + "-size", contentEntry.DecompressedSize, 0);
config.SetValue(type + "-size", encodedEntry.CompressedSize, 1);
}
}
public void Refresh()
{
var file = HostedScriptEngine.ConfigFilePath();
if (file != null)
{
_config = KeyValueConfig.Read(file);
}
}
public async Task <bool> SetAsync(string key, string value)
{
if (string.IsNullOrWhiteSpace(value))
{
throw new ValidationException(nameof(value), "value is empty");
}
var kv = new KVPair(key)
{
Value = KeyValueConfig.ConvertValueToByte(value)
};
var result = await _client.KV.Put(kv);
return(result.Response);
}
public static void BuildConfig(UnshippedBuild model, EncodingFile encoding, long eSize, long eCompressedSize)
{
var config = new KeyValueConfig(ConfigType.BuildConfig);
SetFileInfo(config, "root", model.Root, encoding);
SetFileInfo(config, "install", model.Install, encoding);
SetFileInfo(config, "download", model.Download, encoding);
SetFileInfo(config, "size", model.Size, encoding);
config.SetValue("encoding", encoding.Checksum, 0);
config.SetValue("encoding", model.Encoding, 1);
config.SetValue("encoding-size", eSize, 0);
config.SetValue("encoding-size", eCompressedSize, 1);
config.SetValue("build-name", GetBuildName(model.Product, model.Build));
config.SetValue("build-uid", model.Product);
config.Write(Consts.TempDir);
}
private string WatchCallBackInternal(KeyValueConfig setting, string key)
{
string watchValue = string.Empty;
if (setting == null || string.IsNullOrWhiteSpace(setting.Value))
{
Data.Remove(key);
}
else
{
Data[setting.Key] = setting.Value;
watchValue = setting.Value;
}
OnReload();
lock (LockObj)
{
SetToLocalFile();
}
return(watchValue);
}
public override void Update()
{
switch (TableName)
{
case "V_SYS_UserList":
case "Sys_User":
jsonResult = sysLogic.UpdateUser();
break;
default:
base.Update();
if (TableName == "Config_KeyValue")
{
if (KeyValueConfig.IsChangeLangConfig(GetID))
{
LangConst.InitKeyValue(); //重新始始化多语言
}
}
break;
}
}
public static CASCConfig LoadLocalStorageConfig(string basePath, string product = null)
{
var config = new CASCConfig {
OnlineMode = false, BasePath = basePath, Product = product
};
config.GameType = CASCGame.DetectLocalGame(basePath);
if (config.GameType == CASCGameType.Agent || config.GameType == CASCGameType.Hearthstone)
{
throw new Exception("Local mode not supported for this game!");
}
string buildInfoPath = Path.Combine(basePath, ".build.info");
using (Stream buildInfoStream = new FileStream(buildInfoPath, FileMode.Open))
{
config._BuildInfo = VerBarConfig.ReadVerBarConfig(buildInfoStream);
}
Dictionary <string, string> bi = config.GetActiveBuild(product);
if (bi == null)
{
throw new Exception("Can't find active BuildInfoEntry");
}
string dataFolder = CASCGame.GetDataFolder(config.GameType);
config.ActiveBuild = 0;
config._Builds = new List <KeyValueConfig>();
if (File.Exists("fakebuildconfig"))
{
using Stream stream = new FileStream("fakebuildconfig", FileMode.Open);
var cfg = KeyValueConfig.ReadKeyValueConfig(stream);
config._Builds.Add(cfg);
}
else
{
string buildKey = bi["BuildKey"];
//string buildKey = "5a05c58e28d0b2c3245954b6f4e2ae66";
string buildCfgPath = Path.Combine(basePath, dataFolder, "config", buildKey.Substring(0, 2), buildKey.Substring(2, 2), buildKey);
using Stream stream = new FileStream(buildCfgPath, FileMode.Open);
config._Builds.Add(KeyValueConfig.ReadKeyValueConfig(stream));
}
if (File.Exists("fakecdnconfig"))
{
using Stream stream = new FileStream("fakecdnconfig", FileMode.Open);
config._CDNConfig = KeyValueConfig.ReadKeyValueConfig(stream);
}
else
{
string cdnKey = bi["CDNKey"];
//string cdnKey = "23d301e8633baaa063189ca9442b3088";
string cdnCfgPath = Path.Combine(basePath, dataFolder, "config", cdnKey.Substring(0, 2), cdnKey.Substring(2, 2), cdnKey);
using Stream stream = new FileStream(cdnCfgPath, FileMode.Open);
config._CDNConfig = KeyValueConfig.ReadKeyValueConfig(stream);
}
CDNCache.Init(config);
return(config);
}
public static CASCConfig LoadOnlineStorageConfig(string product, string region, bool useCurrentBuild = false)
{
var config = new CASCConfig {
OnlineMode = true, Region = region, Product = product
};
using (var ribbit = new RibbitClient("us"))
using (var cdnsStream = ribbit.GetAsStream($"v1/products/{product}/cdns"))
{
config._CDNData = VerBarConfig.ReadVerBarConfig(cdnsStream);
}
using (var ribbit = new RibbitClient("us"))
using (var versionsStream = ribbit.GetAsStream($"v1/products/{product}/versions"))
{
config._VersionsData = VerBarConfig.ReadVerBarConfig(versionsStream);
}
for (int i = 0; i < config._VersionsData.Count; ++i)
{
if (config._VersionsData[i]["Region"] == region)
{
config._versionsIndex = i;
break;
}
}
CDNCache.Init(config);
config.GameType = CASCGame.DetectGameByUid(product);
if (File.Exists("fakecdnconfig"))
{
using Stream stream = new FileStream("fakecdnconfig", FileMode.Open);
config._CDNConfig = KeyValueConfig.ReadKeyValueConfig(stream);
}
else
{
string cdnKey = config._VersionsData[config._versionsIndex]["CDNConfig"].ToLower();
//string cdnKey = "da4896ce91922122bc0a2371ee114423";
using Stream stream = CDNIndexHandler.OpenConfigFileDirect(config, cdnKey);
config._CDNConfig = KeyValueConfig.ReadKeyValueConfig(stream);
}
config.ActiveBuild = 0;
config._Builds = new List <KeyValueConfig>();
if (config._CDNConfig["builds"] != null)
{
for (int i = 0; i < config._CDNConfig["builds"].Count; i++)
{
try
{
using Stream stream = CDNIndexHandler.OpenConfigFileDirect(config, config._CDNConfig["builds"][i]);
var cfg = KeyValueConfig.ReadKeyValueConfig(stream);
config._Builds.Add(cfg);
}
catch
{
}
}
if (useCurrentBuild)
{
string curBuildKey = config._VersionsData[config._versionsIndex]["BuildConfig"];
int buildIndex = config._CDNConfig["builds"].IndexOf(curBuildKey);
if (buildIndex != -1)
{
config.ActiveBuild = buildIndex;
}
}
}
if (File.Exists("fakebuildconfig"))
{
using Stream stream = new FileStream("fakebuildconfig", FileMode.Open);
var cfg = KeyValueConfig.ReadKeyValueConfig(stream);
config._Builds.Add(cfg);
}
else
{
string buildKey = config._VersionsData[config._versionsIndex]["BuildConfig"].ToLower();
//string buildKey = "3b0517b51edbe0b96f6ac5ea7eaaed38";
using Stream stream = CDNIndexHandler.OpenConfigFileDirect(config, buildKey);
var cfg = KeyValueConfig.ReadKeyValueConfig(stream);
config._Builds.Add(cfg);
}
return(config);
}
public override bool Initialize(string installationPath)
{
ArchivePath = Path.Combine(installationPath, @"Data\data");
#region Load .build.info and config
var buildInfo = new TokenConfig();
using (var buildInfoReader = new StreamReader(File.OpenRead(Path.Combine(installationPath, ".build.info"))))
buildInfo.Load(buildInfoReader);
var buildKey = buildInfo["Build Key"].FirstOrDefault();
if (string.IsNullOrEmpty(buildKey))
{
throw new InvalidOperationException(".build.info is missing a build key");
}
var buildConfigPath = Path.Combine(installationPath, @"Data\config",
buildKey.Substring(0, 2), buildKey.Substring(2, 2), buildKey);
var buildConfig = new KeyValueConfig();
using (var buildConfigReader = new StreamReader(File.OpenRead(buildConfigPath)))
buildConfig.Load(buildConfigReader);
#endregion
_rootKey = buildConfig["root"].FirstOrDefault().ToByteArray();
_encodingKey = buildConfig["encoding"].ElementAtOrDefault(1).ToByteArray(9);
for (var i = 0; i < 0x10; ++i)
{
var indexFile = Directory.GetFiles(ArchivePath, $"{i:X2}*.idx").Last();
using (var indexFileStream = File.OpenRead(indexFile))
LoadIndex(indexFileStream);
}
var encodingEntry = _indexEntries[_encodingKey];
using (var encodingStream = new BLTE(GetArchive(encodingEntry.Item1), encodingEntry.Item2 + 30, encodingEntry.Item3 - 30, false))
if (!LoadEncoding(encodingStream))
{
throw new InvalidOperationException("Unable to find encoding");
}
// At this point, the only possibility for root to not load is
// that it was parsed from encoding before being found in index
// or that it was not loaded when found in encoding
if (_rootEntries.Count == 0)
{
if (!_encodingEntries.ContainsKey(_rootKey))
{
throw new InvalidOperationException("Root entry not found in encoding!");
}
foreach (var rootEncodingEntry in _encodingEntries[_rootKey])
{
Tuple <int, int, int> indexEntry;
if (!_indexEntries.TryGetValue(rootEncodingEntry.Item2, out indexEntry))
{
continue;
}
using (var rootStream = new BLTE(GetArchive(indexEntry.Item1), indexEntry.Item2 + 30, indexEntry.Item3 - 30))
if (LoadRoot(rootStream))
{
break;
}
}
}
return(_rootEntries.Count != 0);
}
/// <summary>
/// Loads data from disk
/// </summary>
/// <param name="basePath"></param>
/// <param name="useKeyring"></param>
/// <param name="loadMultipleLangs"></param>
/// <returns></returns>
public static CASCConfig LoadLocalStorageConfig(string basePath, bool useKeyring, bool loadMultipleLangs)
{
CASCConfig config = new CASCConfig {
OnlineMode = false,
BasePath = basePath
};
try {
string productDbPath = Path.Combine(basePath, ".product.db");
config.InstallData = new ProductDatabase(productDbPath, true).Data.ProductInstalls[0];
} catch { }
config.SpeechLanguage = config.InstallData?.Settings?.SelectedSpeechLanguage ?? "enUS";
config.TextLanguage = config.InstallData?.Settings?.SelectedTextLanguage ?? "enUS";
string buildInfoPath = Path.Combine(basePath, ".build.info");
using (Stream buildInfoStream = new FileStream(buildInfoPath, FileMode.Open)) {
config._buildInfo = BarSeparatedConfig.Read(buildInfoStream);
}
Dictionary <string, string> bi = config.GetActiveBuild();
if (bi == null)
{
throw new Exception("Can't find active BuildInfoEntry");
}
string dataFolder = GetDataFolder();
config.ActiveBuild = 0;
config.Builds = new List <KeyValueConfig>();
string buildKey = bi["BuildKey"];
string buildCfgPath = Path.Combine(basePath, dataFolder, "config", buildKey.Substring(0, 2), buildKey.Substring(2, 2), buildKey);
try {
using (Stream stream = new FileStream(buildCfgPath, FileMode.Open)) {
config.Builds.Add(KeyValueConfig.Read(stream));
}
} catch {
using (Stream stream = CDNIndexHandler.OpenConfigFileDirect(config, buildKey)) {
config.Builds.Add(KeyValueConfig.Read(stream));
}
}
string cdnKey = bi["CDNKey"];
string cdnCfgPath = Path.Combine(basePath, dataFolder, "config", cdnKey.Substring(0, 2), cdnKey.Substring(2, 2), cdnKey);
try {
using (Stream stream = new FileStream(cdnCfgPath, FileMode.Open)) {
config._cdnConfig = KeyValueConfig.Read(stream);
}
} catch {
using (Stream stream = CDNIndexHandler.OpenConfigFileDirect(config, cdnKey)) {
config._cdnConfig = KeyValueConfig.Read(stream);
}
}
if (bi.ContainsKey("Keyring") && bi["Keyring"].Length > 0)
{
string keyringKey = bi["Keyring"];
string keyringCfgPath = Path.Combine(basePath, dataFolder, "config", keyringKey.Substring(0, 2), keyringKey.Substring(2, 2), keyringKey);
try {
using (Stream stream = new FileStream(keyringCfgPath, FileMode.Open)) {
config.KeyRing = KeyValueConfig.Read(stream);
}
} catch {
using (Stream stream = CDNIndexHandler.OpenConfigFileDirect(config, keyringKey)) {
config.KeyRing = KeyValueConfig.Read(stream);
}
}
if (useKeyring)
{
config.LoadKeyringKeys(TACTKeyService.Keys, true);
}
}
config.InstalledLanguages = new HashSet <string>();
config.LoadAllInstalledLanguages = loadMultipleLangs;
if (bi.ContainsKey("Tags") && bi["Tags"].Trim().Length > 0)
{
string[] tags = bi["Tags"].Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string tag in tags)
{
try {
Enum.Parse(typeof(LocaleFlags), tag.Substring(0, 4));
config.InstalledLanguages.Add(tag);
} catch { }
}
}
// for debugging:
//var buildInfo = config.Builds[config.ActiveBuild];
return(config);
}
public static KeyValueConfig ReadKeyValueConfig(TextReader reader)
{
var result = new KeyValueConfig();
string line;
while ((line = reader.ReadLine()) != null)
{
if (string.IsNullOrWhiteSpace(line) || line.StartsWith("#")) // skip empty lines and comments
continue;
string[] tokens = line.Split(new char[] { '=' }, StringSplitOptions.RemoveEmptyEntries);
if (tokens.Length != 2)
throw new Exception("KeyValueConfig: tokens.Length != 2");
var values = tokens[1].Trim().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
var valuesList = values.ToList();
result.Data.Add(tokens[0].Trim(), valuesList);
}
return result;
}
