FilesExpand file tree

 master

/

SqlApplicationLock.cs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

186 lines (158 loc) · 7.6 KB

 master

/

SqlApplicationLock.cs

Copy path

Top

File metadata and controls

• Code
• Blame

186 lines (158 loc) · 7.6 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

using System;

using System.Collections.Generic;

using System.Data;

using System.Data.Common;

using System.Data.SqlClient;

using System.Linq;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

namespace Medallion.Threading.Sql

{

internal static class SqlApplicationLock

{

public enum Mode

{

Shared,

Update,

Exclusive,

}

public static bool ExecuteAcquireCommand(ConnectionOrTransaction connectionOrTransaction, string lockName, int timeoutMillis, Mode mode)

{

IDbDataParameter returnValue;

using (var command = CreateAcquireCommand(connectionOrTransaction, lockName, timeoutMillis, mode, out returnValue))

{

command.ExecuteNonQuery();

return ParseExitCode((int)returnValue.Value);

}

}

public static async Task<bool> ExecuteAcquireCommandAsync(ConnectionOrTransaction connectionOrTransaction, string lockName, int timeoutMillis, Mode mode, CancellationToken cancellationToken)

{

IDbDataParameter returnValue;

using (var command = CreateAcquireCommand(connectionOrTransaction, lockName, timeoutMillis, mode, out returnValue))

{

await command.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false);

return ParseExitCode((int)returnValue.Value);

}

}

public static void ExecuteReleaseCommand(ConnectionOrTransaction connectionOrTransaction, string lockName)

{

IDbDataParameter returnValue;

using (var command = CreateReleaseCommand(connectionOrTransaction, lockName, out returnValue))

{

command.ExecuteNonQuery();

ParseExitCode((int)returnValue.Value);

}

}

public static async Task ExecuteReleaseCommandAsync(ConnectionOrTransaction connectionOrTransaction, string lockName)

{

IDbDataParameter returnValue;

using (var command = CreateReleaseCommand(connectionOrTransaction, lockName, out returnValue))

{

await command.ExecuteNonQueryAsync(CancellationToken.None);

ParseExitCode((int)returnValue.Value);

}

}

public static IDbCommand CreateAcquireCommand(

ConnectionOrTransaction connectionOrTransaction,

string lockName,

int timeoutMillis,

Mode mode,

out IDbDataParameter returnValue)

{

var command = connectionOrTransaction.Connection.CreateCommand();

command.Transaction = connectionOrTransaction.Transaction;

command.CommandText = "dbo.sp_getapplock";

command.CommandType = CommandType.StoredProcedure;

command.CommandTimeout = timeoutMillis >= 0

// command timeout is in seconds. We always wait at least the lock timeout plus a buffer

? (timeoutMillis / 1000) + 30

// otherwise timeout is infinite so we use the infinite timeout of 0

// (see https://msdn.microsoft.com/en-us/library/system.data.sqlclient.sqlcommand.commandtimeout%28v=vs.110%29.aspx)

: 0;

command.Parameters.Add(CreateParameter(command, "Resource", lockName));

command.Parameters.Add(CreateParameter(command, "LockMode", GetModeString(mode)));

command.Parameters.Add(CreateParameter(command, "LockOwner", command.Transaction != null ? "Transaction" : "Session"));

command.Parameters.Add(CreateParameter(command, "LockTimeout", timeoutMillis));

returnValue = command.CreateParameter();

returnValue.Direction = ParameterDirection.ReturnValue;

command.Parameters.Add(returnValue);

return command;

}

public static IDbCommand CreateReleaseCommand(ConnectionOrTransaction connectionOrTransaction, string lockName, out IDbDataParameter returnValue)

{

var command = connectionOrTransaction.Connection.CreateCommand();

command.Transaction = connectionOrTransaction.Transaction;

command.CommandText = "dbo.sp_releaseapplock";

command.CommandType = CommandType.StoredProcedure;

command.Parameters.Add(CreateParameter(command, "Resource", lockName));

command.Parameters.Add(CreateParameter(command, "LockOwner", command.Transaction != null ? "Transaction" : "Session"));

returnValue = command.CreateParameter();

returnValue.Direction = ParameterDirection.ReturnValue;

command.Parameters.Add(returnValue);

return command;

}

public static bool ParseExitCode(int exitCode)

{

// sp_getapplock exit codes documented at

// https://msdn.microsoft.com/en-us/library/ms189823.aspx

switch (exitCode)

{

case 0:

case 1:

return true;

case -1: // timeout

return false;

case -2: // canceled

throw new OperationCanceledException(GetErrorMessage(exitCode, "canceled"));

case -3: // deadlock

throw new InvalidOperationException(GetErrorMessage(exitCode, "deadlock"));

case -999: // parameter / unknown

throw new ArgumentException(GetErrorMessage(exitCode, "parameter validation or other error"));

default:

if (exitCode <= 0)

throw new InvalidOperationException(GetErrorMessage(exitCode, "unknown"));

return true; // unknown success code

}

}

private static string GetErrorMessage(int exitCode, string type)

{

return string.Format("The request for the distribute lock failed with exit code {0} ({1})", exitCode, type);

}

private static IDbDataParameter CreateParameter(IDbCommand command, string name, object value)

{

var parameter = command.CreateParameter();

parameter.ParameterName = name;

parameter.Value = value;

return parameter;

}

private static string GetModeString(Mode mode)

{

switch (mode)

{

case Mode.Shared: return "Shared";

case Mode.Update: return "Update";

case Mode.Exclusive: return "Exclusive";

default: throw new ArgumentException(nameof(mode));

}

}

}

internal struct ConnectionOrTransaction

{

private object connectionOrTransaction;

public IDbTransaction Transaction => this.connectionOrTransaction as IDbTransaction;

public IDbConnection Connection => this.Transaction?.Connection ?? (this.connectionOrTransaction as IDbConnection);

public ConnectionOrTransaction(IDbConnection connection)

{

if (connection == null) { throw new ArgumentNullException(nameof(connection)); }

this.connectionOrTransaction = connection;

}

public ConnectionOrTransaction(IDbTransaction transaction)

{

if (transaction == null) { throw new ArgumentNullException(nameof(transaction)); }

this.connectionOrTransaction = transaction;

}

public static implicit operator ConnectionOrTransaction(DbTransaction transaction) => new ConnectionOrTransaction(transaction);

public static implicit operator ConnectionOrTransaction(DbConnection connection) => new ConnectionOrTransaction(connection);

}

}