public static T FromCompressBinary <T>(this byte[] binaryData)
{
return(LZ4MessagePackSerializer.Deserialize <T>(binaryData));
}
public T Deserialize <T>(Stream stream)
{
return((EnableLZ4Compression)
? LZ4MessagePackSerializer.Deserialize <T>(stream, Resolver)
: MessagePackSerializer.Deserialize <T>(stream, Resolver));
}
public byte[] Serialize <T>(T value)
{
return((EnableLZ4Compression)
? LZ4MessagePackSerializer.Serialize(value, Resolver)
: MessagePackSerializer.Serialize(value, Resolver));
}
protected override void OnBroadcastEvent(int methodId, ArraySegment <byte> data)
{
switch (methodId)
{
case 908152736: // ZeroArgument
{
var result = LZ4MessagePackSerializer.Deserialize <Nil>(data, resolver);
receiver.ZeroArgument(); break;
}
case -707027732: // OneArgument
{
var result = LZ4MessagePackSerializer.Deserialize <int>(data, resolver);
receiver.OneArgument(result); break;
}
case -897846353: // MoreArgument
{
var result = LZ4MessagePackSerializer.Deserialize <DynamicArgumentTuple <int, string, double> >(data, resolver);
receiver.MoreArgument(result.Item1, result.Item2, result.Item3); break;
}
case 454186482: // VoidZeroArgument
{
var result = LZ4MessagePackSerializer.Deserialize <Nil>(data, resolver);
receiver.VoidZeroArgument(); break;
}
case -1221768450: // VoidOneArgument
{
var result = LZ4MessagePackSerializer.Deserialize <int>(data, resolver);
receiver.VoidOneArgument(result); break;
}
case 1213039077: // VoidMoreArgument
{
var result = LZ4MessagePackSerializer.Deserialize <DynamicArgumentTuple <int, string, double> >(data, resolver);
receiver.VoidMoreArgument(result.Item1, result.Item2, result.Item3); break;
}
case -2034765446: // OneArgument2
{
var result = LZ4MessagePackSerializer.Deserialize <global::Sandbox.NetCoreServer.Hubs.TestObject>(data, resolver);
receiver.OneArgument2(result); break;
}
case 676118308: // VoidOneArgument2
{
var result = LZ4MessagePackSerializer.Deserialize <global::Sandbox.NetCoreServer.Hubs.TestObject>(data, resolver);
receiver.VoidOneArgument2(result); break;
}
case -2017987827: // OneArgument3
{
var result = LZ4MessagePackSerializer.Deserialize <global::Sandbox.NetCoreServer.Hubs.TestObject[]>(data, resolver);
receiver.OneArgument3(result); break;
}
case 692895927: // VoidOneArgument3
{
var result = LZ4MessagePackSerializer.Deserialize <global::Sandbox.NetCoreServer.Hubs.TestObject[]>(data, resolver);
receiver.VoidOneArgument3(result); break;
}
default:
break;
}
}
public static byte[] ComputeSerialized(object obj) => Compute(LZ4MessagePackSerializer.Serialize(obj));
public int Process(Stream content)
{
var memory = new MemoryStream();
content.CopyTo(memory);
int result = -100;
var bytes = memory.ToArray();
var json = Encoding.UTF8.GetString(LZ4MessagePackSerializer.Decode(bytes));
if (string.IsNullOrEmpty(json) || string.IsNullOrWhiteSpace(json))
{
return(result);
}
var resultStream = new MemoryStream();
var package = JsonConvert.DeserializeObject <HttpPipelinePackage>(json);
var cryptorSql = package.Sql;
var sqlBytes = Convert.FromBase64String(cryptorSql);
MemoryStream ms = new MemoryStream(sqlBytes);
CryptoStream cst = new CryptoStream(ms, _cryptoTransform, CryptoStreamMode.Read);
using (StreamReader sr = new StreamReader(cst))
{
var sql = sr.ReadToEnd();
try
{
switch (package.D)
{
case Database.MySql:
{
using (var conn = new MySqlConnection(Configuration.MySqlConnectionString))
{
if (package.Dt == null)
{
result = conn.Execute(sql);
}
else
{
result = conn.Execute(sql, package.Dt);
}
}
break;
}
default:
{
result = -100;
break;
}
}
}
catch (Exception e)
{
Logger.LogError($"Pipeline execute failed {json}: {e}");
throw e;
}
}
return(result);
}
public byte[] Serialize()
{
return(LZ4MessagePackSerializer.Serialize(this));
}
/// <summary>
/// TwitterApiからフォローされているユーザーのリストを取得します。
/// </summary>
/// <returns>フォローされているユーザーのリストを返します。例外発生時はnullを返します。</returns>
private List <UserData> GetFollowersFromTwitterApi()
{
if (!IsInDesignMode)
{
var fileName = DateTime.Now.ToShortDateString().Replace('/', '-') + "_Followers.data";
var userDatas = new List <UserData>();
try
{
for (long cursorTmp = -1; cursorTmp != 0;)
{
var followers = Tokens.Followers.List(
user_id => Tokens.UserId,
cursor => cursorTmp,
count => 200
);
userDatas.AddRange(followers.Result.Select(user => new UserData {
User = user, FollowType = FollowType.NotSet, Favorite = false
}));
cursorTmp = followers.NextCursor;
}
}
catch (Exception error)
{
_loggingService.Logs.Add($"フォロワー一覧の取得に失敗しました。{error.Message}");
Debug.WriteLine($"フォローワー一覧の取得に失敗しました。{error.Message}");
return(null);
}
try
{
using (var streamWriter = File.CreateText($@"Data\{Tokens.ScreenName}\{fileName}"))
{
try
{
LZ4MessagePackSerializer.Serialize(streamWriter.BaseStream, userDatas, TypelessContractlessStandardResolver.Instance);
}
catch (Exception)
{
var errorMessage = $"{fileName} の保存に失敗しました。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
}
}
catch (UnauthorizedAccessException)
{
var errorMessage = $"{fileName} を開くことに失敗しました。必要なアクセス許可がありません。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
catch (ArgumentNullException)
{
var errorMessage = $"{fileName} を開くことに失敗しました。指定したパスがnullです。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
catch (ArgumentException)
{
var errorMessage = $"{fileName} を開くことに失敗しました。パスは長さ0の文字列か、空白のみで構成されているか、または1つ以上の正しくない文字を含んでいます。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
catch (PathTooLongException)
{
var errorMessage = $"{fileName} を開くことに失敗しました。指定したパスかファイル名、またはその両方がシステム定義の最大長を超えています。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
catch (DirectoryNotFoundException)
{
var errorMessage = $"{fileName} を開くことに失敗しました。指定したパスが無効です。マップされていないドライブを指定していませんか？";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
catch (FileNotFoundException)
{
var errorMessage = $"{fileName} を開くことに失敗しました。指定したパスにファイルが見つかりませんでした。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
catch (NotSupportedException)
{
var errorMessage = $"{fileName} を開くことに失敗しました。パスの形式が無効です。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
return(userDatas);
}
else
{
throw new NotSupportedException("デザインモード時にTwitterAPIを呼び出すことはできません。");
}
}
/// <summary>
/// ローカルからツイートのリストのディクショナリーを取得します。
/// </summary>
/// <returns>ツイートのリストのディクショナリーを返します。例外発生時はnullを返します。</returns>
private async Task <Dictionary <long, List <Status> > > GetUserTweetsFromLocalAsync()
{
var fileName = DateTime.Now.ToShortDateString().Replace('/', '-') + "_UserTweets.data";
try
{
using (var streamReader = File.OpenText($@"Data\{Tokens.ScreenName}\{fileName}"))
{
var userTweets = new Dictionary <long, List <Status> >();
try
{
userTweets = LZ4MessagePackSerializer.Deserialize <Dictionary <long, List <Status> > >(streamReader.BaseStream, TypelessContractlessStandardResolver.Instance);
}
catch (Exception)
{
var errorMessage = $"{fileName} を開くことに失敗しました。ファイルが壊れているためデータを再取得します。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(await GetUserTweetsFromTwitterApiAsync()
.ConfigureAwait(false));
}
return(userTweets);
}
}
catch (UnauthorizedAccessException)
{
var errorMessage = $"{fileName} を開くことに失敗しました。必要なアクセス許可がありません。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
catch (ArgumentNullException)
{
var errorMessage = $"{fileName} を開くことに失敗しました。指定したパスがnullです。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
catch (ArgumentException)
{
var errorMessage = $"{fileName} を開くことに失敗しました。パスは長さ0の文字列か、空白のみで構成されているか、または1つ以上の正しくない文字を含んでいます。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
catch (PathTooLongException)
{
var errorMessage = $"{fileName} を開くことに失敗しました。指定したパスかファイル名、またはその両方がシステム定義の最大長を超えています。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
catch (DirectoryNotFoundException)
{
var errorMessage = $"{fileName} を開くことに失敗しました。指定したパスが無効です。マップされていないドライブを指定していませんか？";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
catch (FileNotFoundException)
{
var errorMessage = $"{fileName} を開くことに失敗しました。指定したパスにファイルが見つかりませんでした。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
catch (NotSupportedException)
{
var errorMessage = $"{fileName} を開くことに失敗しました。パスの形式が無効です。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
}
/// <inheritdoc/>
public override byte[] Serialize <T>(T value)
{
return(LZ4MessagePackSerializer.Serialize(value, ContractlessStandardResolverAllowPrivate.Instance));
}
public IObservable <Unit> WriteAsync(T message)
{
var bytes = LZ4MessagePackSerializer.Serialize(message, resolver);
return(inner.WriteAsync(bytes));
}
public static Keypair FromMessagePack(byte[] msgPack)
{
return(LZ4MessagePackSerializer.Deserialize <Keypair>(msgPack));
}
public static Signature Sign(Message m, string password, Keypair kp)
{
return(Sign(LZ4MessagePackSerializer.Serialize(m), password, kp));
}
public static void SavePreset(bool[] pScenes = null, string name = "preset name")
{
Traverse trav = Traverse.Create(phIBL);
ReflectionProbe probe = trav.Field("probeComponent").GetValue <ReflectionProbe>();
int selectedUserLut = 0;
PHIBL.PostProcessing.Utilities.PostProcessingController PPCtrl_obj = trav.Field("PPCtrl").GetValue <PHIBL.PostProcessing.Utilities.PostProcessingController>();
PresetInfo preset = new PresetInfo
{
name = name,
scenes = pScenes,
profile = phIBL.Snapshot(),
nipples = trav.Field("nippleSSS").GetValue <float>(),
shadowDistance = QualitySettings.shadowDistance,
reflectionBounces = RenderSettings.reflectionBounces,
probeResolution = probe.resolution,
probeIntensity = probe.intensity,
enabledLUT = false,
selectedLUT = selectedUserLut,
contributionLUT = 0,
enableDithering = PPCtrl_obj.enableDither
};
File.WriteAllBytes(Directory.GetCurrentDirectory() + "\\Plugins\\PHIBL_PresetLoad\\presets\\" + name + ".preset", LZ4MessagePackSerializer.Serialize(preset));
SetupPresets();
Console.WriteLine("[PHIBL_PresetLoad] Saved preset: " + name);
}
/// <inheritdoc />
public TStruct Deserialize <TStruct>(byte[] serialized)
{
return(UseLZ4 ? LZ4MessagePackSerializer.Deserialize <TStruct>(serialized, Resolver) :
MessagePackSerializer.Deserialize <TStruct>(serialized, Resolver));
}
/// <summary>
/// TwitterApiからツイートのリストのディクショナリーを取得します。
/// </summary>
/// <returns>ツイートのリストのディクショナリーを返します。例外発生時はnullを返します。</returns>
private async Task <Dictionary <long, List <Status> > > GetUserTweetsFromTwitterApiAsync()
{
if (!IsInDesignMode)
{
var fileName = DateTime.Now.ToShortDateString().Replace('/', '-') + "_UserTweets.data";
var usersTweets = new Dictionary <long, List <Status> >();
var tasks = new List <Task <ListedResponse <Status> > >();
foreach (var userData in Follows.Union(Followers, new UserDataEqualityComparer()))
{
tasks.Add(Tokens.Statuses.UserTimelineAsync(user_id => (long)userData.User.Id, count => 200));
if (tasks.Count % 100 == 0)
{
Debug.WriteLine($"Statuses.UserTimelineの呼び出し回数が{usersTweets.Count}回に到達しました。");
}
if (tasks.Count % 900 == 0)
{
const string errorMessage = "レートリミットに達したため15分後に再開します。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
Thread.Sleep(new TimeSpan(0, 16, 0));
await Task.Delay(new TimeSpan(0, 16, 0))
.ConfigureAwait(false);
}
}
var failedCount = 0;
foreach (var task in tasks)
{
try
{
var statuses = await task;
usersTweets[(long)statuses[0].User.Id] = statuses.ToList();
}
catch (Exception)
{
failedCount++;
}
}
if (failedCount > 0)
{
var errorMessage = $"@{failedCount}件のアカウントのツイートの取得に失敗しました。許可されていない鍵アカウントのツイートを取得しようとした可能性があります。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
}
// キャッシュへ保存
_usersTweets = usersTweets;
try
{
using (var streamWriter = File.CreateText($@"Data\{Tokens.ScreenName}\{fileName}"))
{
try
{
LZ4MessagePackSerializer.Serialize(streamWriter.BaseStream, usersTweets, TypelessContractlessStandardResolver.Instance);
}
catch (Exception)
{
var errorMessage = $"{fileName} の保存に失敗しました。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
}
}
catch (UnauthorizedAccessException)
{
var errorMessage = $"{fileName} を開くことに失敗しました。必要なアクセス許可がありません。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
catch (ArgumentNullException)
{
var errorMessage = $"{fileName} を開くことに失敗しました。指定したパスがnullです。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
catch (ArgumentException)
{
var errorMessage = $"{fileName} を開くことに失敗しました。パスは長さ0の文字列か、空白のみで構成されているか、または1つ以上の正しくない文字を含んでいます。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
catch (PathTooLongException)
{
var errorMessage = $"{fileName} を開くことに失敗しました。指定したパスかファイル名、またはその両方がシステム定義の最大長を超えています。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
catch (DirectoryNotFoundException)
{
var errorMessage = $"{fileName} を開くことに失敗しました。指定したパスが無効です。マップされていないドライブを指定していませんか？";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
catch (FileNotFoundException)
{
var errorMessage = $"{fileName} を開くことに失敗しました。指定したパスにファイルが見つかりませんでした。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
catch (NotSupportedException)
{
var errorMessage = $"{fileName} を開くことに失敗しました。パスの形式が無効です。";
_loggingService.Logs.Add(errorMessage);
Debug.WriteLine(errorMessage);
return(null);
}
return(usersTweets);
}
else
{
throw new NotSupportedException("デザインモード時にTwitterAPIを呼び出すことはできません。");
}
}
/// <inheritdoc />
public byte[] Serialize <TStruct>(ref TStruct item)
{
return(UseLZ4 ? LZ4MessagePackSerializer.Serialize(item, Resolver) :
MessagePackSerializer.Serialize(item, Resolver));
}
/// <summary>
/// Serializes this instance
/// </summary>
/// <param name="compress">if set to <c>true</c> [compress].</param>
/// <returns></returns>
public byte[] Serialize(bool compress = true) =>
compress
? LZ4MessagePackSerializer.Serialize <DataPoint>(this)
: MessagePackSerializer.Serialize <DataPoint>(this);
T Convert <T>(T value)
{
var resolver = new WithImmutableDefaultResolver();
return(LZ4MessagePackSerializer.Deserialize <T>(LZ4MessagePackSerializer.Serialize(value, resolver), resolver));
}
public static void Save_Wardrobe(Wardrobe wardrobe, string path0)
{
if (wardrobe.name.Length == 0)
{
serializationWindow.Write(string.Format(
Strings.UNABLE_TO_SAVE,
Strings.WARDROBE.ToLower()
));
serializationWindow.wardrobes_error++;
return;
}
char[] invalidChars = Path.GetInvalidFileNameChars();
if (wardrobe.name.Any(v => invalidChars.Contains(v)))
{
serializationWindow.Write(string.Format(
Strings.CONTAINS_INVALID_CHAR,
Strings.WARDROBE.ToLower(),
wardrobe.name
));
serializationWindow.wardrobes_error++;
return;
}
serializationWindow.wardrobes++;
string path1 = $"{path0}{wardrobe.name}\\";
Dictionary <string, object> state = new Dictionary <string, object>
{
[Strings.STATE_WARDROBE_WEIGHT] = wardrobe.weight,
[Strings.STATE_WARDROBE_ORDER] = wardrobe.layers.Aggregate(
string.Empty,
(a, b) => $"{a}\\{b.name.ToLower()}"
),
[Strings.NAME_MODE] = wardrobe.nameMode
};
for (int i = 0; i < wardrobe.nameList.Count; i++)
{
state[Strings.STATE_WARDROBE_NAME_LIST + i] = wardrobe.nameList[i];
}
if (!Directory.Exists(path1))
{
Directory.CreateDirectory(path1);
serializationWindow.Write(string.Format(
Strings.CREATED_NEW_FOLDER,
Strings.WARDROBE.ToLower(),
wardrobe.name
));
}
File.WriteAllBytes(path1 + Strings.STATE_BIN, LZ4MessagePackSerializer.Serialize(state));
foreach (Layer layer in wardrobe.layers)
{
Save_Layer(layer, path1);
}
// Delete unused layers.
foreach (string path2 in Directory.GetDirectories(path1))
{
if (!wardrobe.layers.Any(v => v.name.ToLower() == Path.GetFileName(path2).ToLower()))
{
Directory.Delete(path2, true);
serializationWindow.Write(string.Format(
Strings.DELETE_UNUSED,
Strings.LAYER.ToLower(),
Path.GetFileName(path2)
));
serializationWindow.layers_deleted++;
}
}
}
private IEnumerator LoadCacheInternal(IObserver <bool> observer, AesManaged aesManaged)
{
var sw = System.Diagnostics.Stopwatch.StartNew();
#if UNITY_EDITOR
try
{
MessagePackValidater.ValidateAttribute(typeof(TCache));
MessagePackValidater.ValidateAttribute(typeof(T));
}
catch (Exception exception)
{
Debug.LogException(exception);
}
#endif
var installPath = GetLocalCacheFilePath();
Func <string, AesManaged, byte[]> loadCacheFile = (_installPath, _aesManaged) =>
{
// ファイル読み込み.
var data = File.ReadAllBytes(_installPath);
// 復号化.
return(data.Decrypt(_aesManaged));
};
// ファイルの読み込みと復号化をスレッドプールで実行.
var loadYield = Observable.Start(() => loadCacheFile(installPath, aesManaged)).ObserveOnMainThread().ToYieldInstruction();
while (!loadYield.IsDone)
{
yield return(null);
}
var result = false;
if (loadYield.HasResult)
{
var data = loadYield.Result;
try
{
var cachedData = LZ4MessagePackSerializer.Deserialize <TCache>(data, UnityContractResolver.Instance);
SetMaster(cachedData.values);
result = true;
}
catch (Exception exception)
{
Debug.LogException(exception);
}
}
sw.Stop();
if (result)
{
MasterCacheLoadDiagnostic.Instance.Register <TInstance>(sw.Elapsed.TotalMilliseconds);
}
else
{
File.Delete(installPath);
OnError();
}
observer.OnNext(result);
observer.OnCompleted();
}
public static void Save_Layer(Layer layer, string path0)
{
if (layer.name.Length == 0)
{
serializationWindow.Write(string.Format(
Strings.UNABLE_TO_SAVE,
Strings.LAYER.ToLower()
));
serializationWindow.layers_error++;
return;
}
char[] invalidChars = Path.GetInvalidFileNameChars();
if (layer.name.Any(v => invalidChars.Contains(v)))
{
serializationWindow.Write(string.Format(
Strings.CONTAINS_INVALID_CHAR,
Strings.LAYER.ToLower(),
layer.name
));
serializationWindow.layers_error++;
return;
}
serializationWindow.layers++;
string path1 = $"{path0}{layer.name}\\";
Dictionary <string, object> state = new Dictionary <string, object>();
if (!Directory.Exists(path1))
{
Directory.CreateDirectory(path1);
serializationWindow.Write(string.Format(
Strings.CREATED_NEW_FOLDER,
Strings.LAYER.ToLower(),
layer.name
));
}
File.WriteAllBytes(path1 + Strings.CHECK_LIST_BIN, layer.checkList.ToBytes());
File.WriteAllBytes(path1 + Strings.CHECK_LIST_KKABMX_BIN, layer.checkList_KKABMX.ToBytes());
File.WriteAllBytes(path1 + Strings.CHECK_LIST_KSOX_BIN, layer.checkList_KSOX.ToBytes());
File.WriteAllBytes(path1 + Strings.CHECK_LIST_KCOX_BIN, layer.checkList_KCOX.ToBytes());
foreach (Card card in layer.cards)
{
string path2 = path1 + card.name;
state[card.name.ToLower()] = card.weight;
if (File.Exists(path2))
{
serializationWindow.Write(string.Format(
Strings.CARD_OVERWRITE,
card.name
));
}
else
{
serializationWindow.Write(string.Format(
Strings.CARD_SAVED,
card.name
));
}
File.WriteAllBytes(path2, card.saveData);
serializationWindow.cards++;
}
File.WriteAllBytes(path1 + Strings.STATE_BIN, LZ4MessagePackSerializer.Serialize(state));
// Delete unused cards.
foreach (string path2 in Directory.GetFiles(path1))
{
if (Path.GetExtension(path2).ToLower() != Strings.CARD_EXTENSION)
{
continue;
}
if (!layer.cards.Any(v => v.name.ToLower() == Path.GetFileName(path2).ToLower()))
{
File.Delete(path2);
serializationWindow.Write(string.Format(
Strings.DELETE_UNUSED,
Strings.CARD.ToLower(),
path2
));
serializationWindow.cards_deleted++;
}
}
}
protected override void OnResponseEvent(int methodId, object taskCompletionSource, ArraySegment <byte> data)
{
switch (methodId)
{
case 908152736: // ZeroArgument
{
var result = LZ4MessagePackSerializer.Deserialize <Nil>(data, resolver);
((TaskCompletionSource <Nil>)taskCompletionSource).TrySetResult(result);
break;
}
case -707027732: // OneArgument
{
var result = LZ4MessagePackSerializer.Deserialize <Nil>(data, resolver);
((TaskCompletionSource <Nil>)taskCompletionSource).TrySetResult(result);
break;
}
case -897846353: // MoreArgument
{
var result = LZ4MessagePackSerializer.Deserialize <Nil>(data, resolver);
((TaskCompletionSource <Nil>)taskCompletionSource).TrySetResult(result);
break;
}
case 1229270708: // RetrunZeroArgument
{
var result = LZ4MessagePackSerializer.Deserialize <int>(data, resolver);
((TaskCompletionSource <int>)taskCompletionSource).TrySetResult(result);
break;
}
case -2084706656: // RetrunOneArgument
{
var result = LZ4MessagePackSerializer.Deserialize <string>(data, resolver);
((TaskCompletionSource <string>)taskCompletionSource).TrySetResult(result);
break;
}
case -1898269861: // RetrunMoreArgument
{
var result = LZ4MessagePackSerializer.Deserialize <double>(data, resolver);
((TaskCompletionSource <double>)taskCompletionSource).TrySetResult(result);
break;
}
case -2034765446: // OneArgument2
{
var result = LZ4MessagePackSerializer.Deserialize <Nil>(data, resolver);
((TaskCompletionSource <Nil>)taskCompletionSource).TrySetResult(result);
break;
}
case -168691754: // RetrunOneArgument2
{
var result = LZ4MessagePackSerializer.Deserialize <global::Sandbox.NetCoreServer.Hubs.TestObject>(data, resolver);
((TaskCompletionSource <global::Sandbox.NetCoreServer.Hubs.TestObject>)taskCompletionSource).TrySetResult(result);
break;
}
case -2017987827: // OneArgument3
{
var result = LZ4MessagePackSerializer.Deserialize <Nil>(data, resolver);
((TaskCompletionSource <Nil>)taskCompletionSource).TrySetResult(result);
break;
}
case -151914135: // RetrunOneArgument3
{
var result = LZ4MessagePackSerializer.Deserialize <global::Sandbox.NetCoreServer.Hubs.TestObject[]>(data, resolver);
((TaskCompletionSource <global::Sandbox.NetCoreServer.Hubs.TestObject[]>)taskCompletionSource).TrySetResult(result);
break;
}
default:
break;
}
}
public static void SetLz4 <T>(this IDistributedCache cache, string key, T value, TimeSpan slidingExpiration) where T : class
{
cache.Set(key, LZ4MessagePackSerializer.Serialize(value, ContractlessStandardResolver.Instance), new DistributedCacheEntryOptions().SetSlidingExpiration(slidingExpiration));
}
protected override void OnReload(GameMode currentGameMode, bool maintainState)
{
foreach (var modifier in Modifiers)
{
modifier.Reset();
}
// Stop baseline collection if it's running
StopAllCoroutines();
_baselineKnown = false;
if (!maintainState && (GUI.KKABMX_GUI.LoadBody || GUI.KKABMX_GUI.LoadFace))
{
var newModifiers = new List <BoneModifier>();
var data = GetExtendedData();
if (data != null)
{
try
{
switch (data.version)
{
case 2:
newModifiers = LZ4MessagePackSerializer.Deserialize <List <BoneModifier> >((byte[])data.data[ExtDataBoneDataKey]);
break;
case 1:
Logger.Log(LogLevel.Debug, $"[KKABMX] Loading legacy embedded ABM data from card: {ChaFileControl.parameter?.fullname}");
newModifiers = OldDataConverter.MigrateOldExtData(data);
break;
default:
throw new NotSupportedException($"Save version {data.version} is not supported");
}
}
catch (Exception ex)
{
Logger.Log(LogLevel.Error, "[KKABMX] Failed to load extended data - " + ex);
}
}
if (GUI.KKABMX_GUI.LoadBody && GUI.KKABMX_GUI.LoadFace)
{
Modifiers = newModifiers;
}
else
{
var headRoot = transform.FindLoop("cf_j_head");
var headBones = new HashSet <string>(headRoot.GetComponentsInChildren <Transform>().Select(x => x.name));
headBones.Add(headRoot.name);
if (GUI.KKABMX_GUI.LoadFace)
{
Modifiers.RemoveAll(x => headBones.Contains(x.BoneName));
Modifiers.AddRange(newModifiers.Where(x => headBones.Contains(x.BoneName)));
}
else if (GUI.KKABMX_GUI.LoadBody)
{
var bodyBones = new HashSet <string>(transform.FindLoop("BodyTop").GetComponentsInChildren <Transform>().Select(x => x.name).Except(headBones));
Modifiers.RemoveAll(x => bodyBones.Contains(x.BoneName));
Modifiers.AddRange(newModifiers.Where(x => bodyBones.Contains(x.BoneName)));
}
}
}
StartCoroutine(OnDataChangedCo());
}
public static Task SetLz4Async <T>(this IDistributedCache cache, string key, T value, TimeSpan slidingExpiration, CancellationToken token = default(CancellationToken)) where T : class
{
return(cache.SetAsync(key, LZ4MessagePackSerializer.Serialize(value, ContractlessStandardResolver.Instance), new DistributedCacheEntryOptions().SetSlidingExpiration(slidingExpiration), token));
}
public T Deserialize <T>(byte[] rawBytes)
{
return((EnableLZ4Compression)
? LZ4MessagePackSerializer.Deserialize <T>(rawBytes, Resolver)
: MessagePackSerializer.Deserialize <T>(rawBytes, Resolver));
}
async Task <TResponse> Deserialize()
{
var bytes = await inner.ResponseAsync.ConfigureAwait(false);
return(LZ4MessagePackSerializer.Deserialize <TResponse>(bytes, resolver));
}
public void Subscribe <TData>(string topic, Action <MessageData <TData> > action)
{
if (_consumers.ContainsKey(topic))
{
_logger?.LogError($"Already subscribe {topic}");
return;
}
if (_options.PartitionTopics.Contains(topic))
{
var adminClientConfig = new AdminClientConfig();
SetClientConfig(adminClientConfig);
using (var adminClient = new AdminClientBuilder(adminClientConfig).Build())
{
try
{
PrepareTopic(adminClient, topic);
}
catch (CreateTopicsException)
{
// ignore
}
}
}
var config = new ConsumerConfig
{
GroupId = _options.ConsumerGroup,
// Note: The AutoOffsetReset property determines the start offset in the event
// there are not yet any committed offsets for the consumer group for the
// topic/partitions of interest. By default, offsets are committed
// automatically, so in this example, consumption will only start from the
// earliest message in the topic 'my-topic' the first time you run the program.
AutoOffsetReset = AutoOffsetReset.Earliest
};
SetClientConfig(config);
var consumer = new ConsumerBuilder <Null, byte[]>(config).Build();
consumer.Subscribe(topic);
_consumers.TryAdd(topic, consumer);
Task.Factory.StartNew(() =>
{
_logger.LogInformation("Subscribe: " + topic);
while (_consumers.ContainsKey(topic))
{
TransferMessage msg = null;
try
{
var value = consumer.Consume().Value;
msg = LZ4MessagePackSerializer.Deserialize <TransferMessage>(value,
TypelessContractlessStandardResolver.Instance);
}
catch (ObjectDisposedException)
{
_logger?.LogDebug("Kafka handler is disposed");
}
catch (Exception e)
{
_logger?.LogError($"Consume kafka message failed on topic {topic}: {e}");
}
if (msg != null)
{
Task.Factory.StartNew(() =>
{
action?.Invoke(new MessageData <TData>
{
Timestamp = msg.Timestamp,
Type = msg.Type,
Data = LZ4MessagePackSerializer.Deserialize <TData>(msg.Data,
TypelessContractlessStandardResolver.Instance)
});
}).ContinueWith(t =>
{
if (t.Exception != null)
{
_logger?.LogError($"Handle kafka message failed on topic {topic}: {t}");
}
});
}
else
{
_logger?.LogWarning($"Ignore empty kafka message on topic {topic}");
}
}
_logger?.LogWarning($"Exit consume kafka topic {topic}");
}).ConfigureAwait(true);
}
public static byte[] ToCompressBinary <T>(this T obj)
{
return(LZ4MessagePackSerializer.Serialize(obj));
}
