public async Task SetupAsync(ObjectLock <DiscordClientEx> discordClient)
{
_discordClient = discordClient;
await _discordClient.DoAsync((client) =>
{
client.ReactionAdded += DiscordClient_ReactionAdded;
client.ReactionRemoved += DiscordClient_ReactionRemoved;
client.ReactionsCleared += DiscordClient_ReactionsCleared;
}).ConfigureAwait(false);
}
/// <inheritdoc />
public async Task <bool> LockedAsync(TDataType objectId)
{
ObjectLock <TDataType>?exists = await this._database.QuerySingleOrDefaultAsync(builder : this._lockBuilder, storedProcedure : this._objectLockProcedures.IsLocked, new { ObjectId = objectId });
if (exists != null)
{
this._logger.LogDebug($"Object is currently locked by {exists.LockedBy} on {exists.LockedAt}");
return(true);
}
return(false);
}
/// <inheritdoc />
public async Task <bool> AcquireAsync(TDataType objectId)
{
ObjectLock <TDataType>?exists = await this._database.QuerySingleOrDefaultAsync(builder : this._lockBuilder,
storedProcedure : this._objectLockProcedures.Acquire,
new { ObjectId = objectId, MachineName = this._machineName });
if (exists != null)
{
this._logger.LogDebug($"Object was locked by {exists.LockedBy} on {exists.LockedAt}");
return(true);
}
return(false);
}
public static void SaveLock(ObjectLock oLock)
{
if (GameInformation.ObjectLocks.Count <= oLock.lockIndex)
{
LockData newLock = new LockData();
for (int i = 0; i < oLock.lockIndex + 1; i++)
{
if (i <= GameInformation.ObjectLocks.Count)
{
GameInformation.ObjectLocks.Insert(i, newLock);
}
}
//GameInformation.NPCData.Insert(npc.NPCIndex, newNPC);
}
GameInformation.ObjectLocks[oLock.lockIndex].locked = oLock.IsLocked();
GameInformation.ObjectLocks[oLock.lockIndex].index = oLock.lockIndex;
}
protected Task <IDisposable> WriteLock()
{
lock (lockLock) {
var ts = new TaskCompletionSource <IDisposable> ();
var ol = new ObjectLock {
Object = this, IsWriteLock = true, TaskSource = ts
};
if (writeLockTaken || readLocksTaken > 0)
{
if (lockRequests == null)
{
lockRequests = new Queue <ObjectLock> ();
}
lockRequests.Enqueue(ol);
}
else
{
writeLockTaken = true;
ts.SetResult(ol);
}
return(ts.Task);
}
}
public async Task <bool> RunAsync()
{
if (_firstStart)
{
Log.Setup(true, false);
Log.Info("Starting Ditto...");
}
// Try to load the settings from the XML file.
// Should this not exist, it will automatically create one.
try
{
Settings = await SettingsConfiguration.ReadAsync("data/settings.xml");
// Write the settings again to update it with any new properties that might have been added.
await Settings.WriteAsync("data/settings.xml").ConfigureAwait(false);
}
catch (Exception ex)
{
Log.Fatal(ex);
return(false);
}
// Try to initialize the database
try
{
(Database = new DatabaseHandler()).Setup(Settings.Credentials.Sql.Type, Settings.Credentials.Sql.ConnectionString);
}
catch (Exception ex)
{
Log.Fatal("Unable to create a connection with the database, please check the file \"/data/settings.xml\"", ex);
return(false);
}
// Try to initialise the service 'Google'
try
{
await(Google = new GoogleService()).SetupAsync(Settings.Credentials.GoogleApiKey).ConfigureAwait(false);
}
catch (Exception ex)
{
Log.Error("Could not initialize Google {0}\n", ex.ToString());
}
// Try to initialise 'Giphy'
try
{
Giphy = new Giphy(Settings.Credentials.GiphyApiKey);
}
catch (ApiException ex)
{
Log.Warn("Could not initialize Giphy {0}\n", ex.ToString());
}
// Try to initialise 'Twitch'
try
{
Twitch = new TwitchLib.Api.TwitchAPI();
Twitch.Settings.ClientId = Settings.Credentials.TwitchApiClientId;
Twitch.Settings.Secret = Settings.Credentials.TwitchApiSecret;
var twitchResult = await Twitch.V5.Auth.CheckCredentialsAsync().ConfigureAwait(false);
if (Twitch.Settings.ClientId == null || !twitchResult.Result)
{
Twitch = null;
throw new ApiException("Twitch credentials check failed.");
}
}
catch (Exception ex)
{
Log.Warn("Could not initialize Twitch {0}\n", ex.ToString());
}
// Create our discord client
Client?.Dispose();
Client = new ObjectLock <DiscordClientEx>(new DiscordClientEx(new DiscordSocketConfig()
{
MessageCacheSize = Settings.Cache.AmountOfCachedMessages,
LogLevel = LogSeverity.Warning,
//TotalShards = 1,
ConnectionTimeout = (int)(Settings.Timeout * 60),
HandlerTimeout = (int)(Settings.Timeout * 60),
DefaultRetryMode = RetryMode.AlwaysRetry,
//AlwaysDownloadUsers = true,
}), 1, 1);
// Various services
if (Cache == null)
{
(Cache = new CacheHandler()).Setup(TimeSpan.FromSeconds(Settings.Cache.CacheTime));
}
CommandHandler?.Dispose();
await(CommandHandler = new CommandHandler(Client)).SetupAsync().ConfigureAwait(false);
await Client.DoAsync((client)
=> client.Connected += async() =>
{
// Setup services
await CommandHandler.SetupAsync().ConfigureAwait(false);
ReactionHandler?.Dispose();
await(ReactionHandler = new ReactionHandler()).SetupAsync(Client).ConfigureAwait(false);
PlayingStatusHandler.Setup(TimeSpan.FromMinutes(1));
}
).ConfigureAwait(false);
if (_firstStart)
{
Connected += async() =>
{
// Start services
await CommandHandler.StartAsync().ConfigureAwait(false);
PlayingStatusHandler.Start();
Connected -= Initialised;
};
// Call this once after a successful connection.
Connected += Initialised;
}
await Client.DoAsync((client)
=> client.Ready += async() =>
{
if (!Running)
{
Running = true;
await Connected().ConfigureAwait(false);
}
Log.Info("Connected");
if (Type == BotType.Bot)
{
await client.SetGameAsync(null);
await client.SetStatusAsync(UserStatusEx.Online);
}
}
).ConfigureAwait(false);
await Client.DoAsync((client)
=> client.Disconnected += (e) =>
{
if (Reconnecting)
{
//_reconnecting = false;
}
else
{
Log.Warn("Bot has been disconnected. {0}", (object)(Exiting ? null : $"| {e}"));
if (!Exiting && Settings.AutoReconnect && !Reconnecting)
{
var _ = Task.Run(() => ReconnectAsync());
}
}
return(Task.CompletedTask);
}
).ConfigureAwait(false);
await Client.DoAsync((client)
=> client.LoggedOut += () =>
{
Log.Warn("Bot has logged out.");
if (!Exiting && Settings.AutoReconnect && !Reconnecting)
{
var _ = Task.Run(() => ReconnectAsync());
}
return(Task.CompletedTask);
}
).ConfigureAwait(false);
var autoReconnect = Settings.AutoReconnect;
Settings.AutoReconnect = false;
try
{
await LoginAsync().ConfigureAwait(false);
Settings.AutoReconnect = autoReconnect;
}
catch (Exception ex)
{
Log.Fatal("Failed to login, please check your internet connection and bot token.", ex);
return(false);
}
await Client.DoAsync((c) => c.StartAsync()).ConfigureAwait(false);
_firstStart = false;
return(true);
}
private void Awake()
{
objLock = GameObject.FindGameObjectWithTag("Player").GetComponent <ObjectLock>();
}
public void TestObjectLockPerformance()
{
bool _IsSingleCore = (Environment.ProcessorCount == 1);
//---------------------------------------------------------------
{
object target = new object();
Stopwatch sw = new Stopwatch();
sw.Start();
int lockedCount = 0;
for (int i = 0; i < TestIterations; i++)
{
lock (target)
{
lockedCount++;
}
}
sw.Stop();
Debug.Print("BenchmarkC#LockPattern : {0} seconds, {1} locks/ms",
sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds);
}
//---------------------------------------------------------------
// ----------- this is the lowest overhead technique ------------
//---------------------------------------------------------------
{
Stopwatch sw = new Stopwatch();
sw.Start();
int lockedCount = 0;
int _Spinlock = 0;
for (int i = 0; i < TestIterations; i++)
{
while (Interlocked.CompareExchange(ref _Spinlock, 1, 0) != 0)
{
if (_IsSingleCore)
{
Thread.Sleep(0);
}
}
try
{
lockedCount++;
}
finally
{
Interlocked.Exchange(ref _Spinlock, 0);
}
}
sw.Stop();
Debug.Print("InlineInterlockedInt32 : {0} seconds, {1} locks/ms",
sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds);
}
//---------------------------------------------------------------
{
object target = new object();
Stopwatch sw = new Stopwatch();
sw.Start();
int lockedCount = 0;
for (int i = 0; i < TestIterations; i++)
{
Monitor.Enter(target);
try
{
lockedCount++;
}
finally
{
Monitor.Exit(target);
}
}
sw.Stop();
Debug.Print("SystemMonitorEnterExit : {0} seconds, {1} locks/ms",
sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds);
}
//---------------------------------------------------------------
{
object target = new object();
Stopwatch sw = new Stopwatch();
sw.Start();
int lockedCount = 0;
for (int i = 0; i < TestIterations; i++)
{
int spinCount = 0;
object lockedObject = null;
while ((lockedObject = Interlocked.Exchange <object>(ref target, null)) == null)
{
if (_IsSingleCore)
{
Thread.Sleep(0);
}
else
{
spinCount++;
if (spinCount % 4000 == 0)
{
Thread.Sleep(0);
}
}
}
try
{
lockedCount++;
}
finally
{
Interlocked.Exchange <object>(ref target, lockedObject);
}
}
sw.Stop();
Debug.Print("InlineInterlockedObject: {0} seconds, {1} locks/ms",
sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds);
}
//---------------------------------------------------------------
{
SpinLock spinlockFast = new SpinLock(false);
Stopwatch sw = new Stopwatch();
sw.Start();
int lockedCount = 0;
for (int i = 0; i < TestIterations; i++)
{
bool lockTaken = false;
while (!lockTaken)
{
spinlockFast.Enter(ref lockTaken);
try
{
if (lockTaken)
{
lockedCount++;
}
}
finally
{
if (lockTaken)
{
spinlockFast.Exit();
}
}
}
}
sw.Stop();
Debug.Print("Net4SpinlockPatternFast: {0} seconds, {1} locks/ms",
sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds);
}
//---------------------------------------------------------------
{
SpinLock spinlockSlow = new SpinLock(true);
Stopwatch sw = new Stopwatch();
sw.Start();
int lockedCount = 0;
for (int i = 0; i < TestIterations; i++)
{
bool lockTaken = false;
while (!lockTaken)
{
spinlockSlow.Enter(ref lockTaken);
try
{
if (lockTaken)
{
lockedCount++;
}
}
finally
{
if (lockTaken)
{
spinlockSlow.Exit();
}
}
}
}
sw.Stop();
Debug.Print("Net4SpinlockPatternSlow: {0} seconds, {1} locks/ms",
sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds);
}
//---------------------------------------------------------------
{
object target = new object();
Stopwatch sw = new Stopwatch();
sw.Start();
int lockedCount = 0;
for (int i = 0; i < TestIterations; i++)
{
object lockedObject = ObjectLock <object> .Enter(ref target);
try
{
lockedCount++;
}
finally
{
ObjectLock <object> .Leave(ref target, lockedObject);
}
}
sw.Stop();
Debug.Print("EnterLeaveCallsPattern : {0} seconds, {1} locks/ms",
sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds);
}
//---------------------------------------------------------------
{
object target = new object();
Stopwatch sw = new Stopwatch();
sw.Start();
int lockedCount = 0;
for (int i = 0; i < TestIterations; i++)
{
ObjectLock <object> .Protect(ref target, delegate(object lockedObject)
{
lockedCount++;
});
}
sw.Stop();
Debug.Print("LockedDelegatePattern : {0} seconds, {1} locks/ms",
sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds);
}
//---------------------------------------------------------------
{
object target = new object();
Guarded <object> wrapper = new Guarded <object>(target);
Stopwatch sw = new Stopwatch();
sw.Start();
int lockedCount = 0;
for (int i = 0; i < TestIterations; i++)
{
//int n = (i % TargetObjects);
wrapper.Locked((lockedObject) =>
{
lockedCount++;
});
}
sw.Stop();
Debug.Print("GuardedWrapperPattern : {0} seconds, {1} locks/ms",
sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds);
}
}
private void UnlockObject(ObjectLock activeLock)
{
_repository.Remove(activeLock);
_repository.UnitOfWork.Commit();
}
private void RefreshLock(ObjectLock activeLock)
{
activeLock.LastModified = DateTime.UtcNow;
_repository.Update(activeLock);
_repository.UnitOfWork.Commit();
}
