Develop Reference

Is there common pattern to sychronize access token creation from multiple threads?

I have a client to OData system, and it (system) works in following way.
first I have to send a special request to retrieve a token.
then I make my requests, attaching token to each request.
at certain time request may fail, saying that token is outdated. then I should make another special request to get a new token
This is easy when I have only one thread. But I want to have multiple threads doing requests and all sharing the same token. Also if more than one concurrent requests fail with token being invalidated I want to send a special request exactly once and other clients to start using the updated token.
If it matters I am using C#.
Is there a common solution to synchronize such requests?

Without knowing much more about your implementation, one option could be MemoryCache.
Your threads could check the cache for a specific 'tokenkey' and get its value. You can set a expiration in your MemoryCache ahead of a known expiration if you wanted to prevent 401s or other unauthorized results.
Here's an example I use to get/set a new token required for auth header in web api calls:
private string GetNewToken()
{
lock (cacheLock)
{
// no token in cache so go get a new one
var newToken = TokenServiceAgent.GetJwt();
// number of minutes (offset) before JWT expires that will trigger update of cache
var cacheLifetime = 15
CacheItemPolicy cip = new CacheItemPolicy()
{
AbsoluteExpiration = new DateTimeOffset(DateTime.Now.AddMinutes(cacheLifetime.Value))
};
MemoryCache.Default.Set("tokenkey", newToken, cip);
return newToken;
}
}
EDIT: can't get the code block to play nice in the SO editor

Cancel yield from host

I have a network application that uses Lua scripts. Upon starting the application I create a global Lua state and load all script files, that contain various functions, and for every client that connects I create a Lua thread, for that connection.
// On start
var GL = luaL_newstate();
// register functions...
// load scripts...
// On connection
connection.State = lua_newthread(GL);
When a request that uses a script comes in, I get the global function and call it.
var NL = connection.State;
var result = lua_resume(NL, 0);
if (result != 0 && result != LUA_YIELD)
{
// error...
result = 0;
}
if (result == 0)
{
// function returned...
}
Now, some scripts require a response to something from the client, so I yield in those functions, to wait for it. When the response comes in, the script is resumed with lua_resume(NL, 1).
// Lua
text("How are you?")
local response = select("Good", "Bad")
// Host
private int select(IntPtr L)
{
// send response request...
return lua_yield(L, 1);
}
// On response
lua_pushstring(NL, response);
var result = lua_resume(NL, 1);
// ...
My problem is that I need to be able to cancel that yield, and return from the Lua function, without executing any more code in the Lua function, and without adding additional code to the scripts. In other words, I basically want to make the Lua thread throw an exception, get back to the start, and forget it ever executed that function.
Is that possible?
One thing I thought might work, but didn't, was calling lua_error. The result was an SEHException on the lua_error call. I assume because the script isn't currently running, but yielding.

While I didn't find a way to wipe a thread's slate clean (I don't think it's possible), I did find a solution in figuring out how lua_newthread works.
When the thread is created, the reference to it is put on the "global" state's stack, and it doesn't get collected until it's removed from there. All you have to do to clean up the thread is removing it from the stack with lua_remove. This requires you to create new threads regularly, but that's not much of a problem for me.
I'm now keeping track of the created threads and their index on the stack, so I can removed them when I'm done with them for whatever reason (cancel, error, etc). All other indices are updated, as the removal will shift the ones that came after it.
if (sessionOver)
{
lua_remove(GL, thread.StackIndex);
foreach (var t in threads)
{
if (t.StackIndex > thread.StackIndex)
t.StackIndex--;
}
}

Lock http requests for exclusive resource access

I have a service which looks locally in a sql table for a value. If the value does not exist it is doing a remote call. If there is a value returned from the remote call then this value is added to the local sql table.
I have notified Unique Index exceptions in the log file that the string value XXX already exists.
To me that means that the following happened:
Request1_localSqlCheck
Request1_remoteCheck
Request2_localSqlCheck
Request2_remoteCheck
Request1_AddValueLocallyIfRecievedByRemote
Request2_AddValueLocallyIfRecievedByRemote // Same value Added here causes exception.
I want to make all 3 steps atom and lock it:
Lock
{
Request1_localSqlCheck
Request1_remoteCheck
Request1_AddValueLocallyIfRecievedByRemote
}
Will this work putting a lock around these 3 method calls?

You could use a Mutex to block the code execution until the server returns the value.
For example:
private readonly Mutex m = new Mutex();
public int ThreadSafeMethod() {
// you can do this immediately to skip the mutex
if (Request1_localSqlCheck == 1) return 1;
m.WaitOne();
try {
// check again
if (Request1_localSqlCheck == 1) return 1;
Request1_remoteCheck
Request1_AddValueLocallyIfRecievedByRemote
} finally {
m.ReleaseMutex();
}
}
Just to be clear, it can be really problematic if this code is called very frequently because it will slow down all the other thread that will have to wait for the mutex.
IMHO, if the "unique" error is not a big deal, I think you can stick with it; it can be boring, but sometimes is better to try and fail than wait for mutex release and slow down everything.

Transactional messages without receiver look - session peeking

I have a distributed service that takes anywhere from 10 sec to 10 min to process a message. The service starts on a user's (== browser) request which is received through an API. Due to various limitations, the result of the service has to be returned outside of the initial request (timeouts, dropped client connections ...) Therefore I return a SessionId to the requesting user which can be used to retrieve the result until it expires.
Now it can happen that a user makes multiple consecutive requests for the result while the session is still locked. For example the following code gets hit with the same SessionId within 60 seconds:
var session = await responseQueue.AcceptMessageSessionAsync(sessionId);
var response = await session.ReceiveAsync(TimeSpan.FromSeconds(60));
if (response == null)
{
session.Abort();
return null;
}
await response.AbandonAsync();
What I need is a setup without locking and the ability to read a message multiple times until it expires plus the ability to wait for yet non-existent messages.
Which ServiceBus solution fits that bill?
UPDATE
Here's a dirty solution, still looking for a better way:
MessageSession session = null;
try
{
session = await responseQueue.AcceptMessageSessionAsync(sessionId);
}
catch
{
// ... and client has to try again until the 60 sec lock from other requests is released
}
var response = await session.ReceiveAsync(TimeSpan.FromSeconds(60));
// ...

Completing Oauth without the use of threading

I am not exactly sure how to explain this so I'll give it my best shot.
Basically I have an application that connects to DropBox. One of the situations I have run into is with the registering process. At the moment during the registration process it connects to DropBox using the default browser, which it then requires the user to login and click allow app to use the service. In return you get a token which the app can use to connect to the service with. The problem I am having is getting the application to wait until the above process is completed. The only way I have figured out to get it to wait is to use system.threading(int). however if the person takes longer then the timeout then it fails to register properly.
I am hoping someone may be able to point me in the right direction and get it to wait without the threading function. I was hoping I could use a if loop or something but i have no idea how to do that properly.
here is the actual Oauth code:
private static OAuthToken GetAccessToken()
{
string consumerKey = "*****";
string consumerSecret = "****";
var oauth = new OAuth();
var requestToken = oauth.GetRequestToken(new Uri(DropboxRestApi.BaseUri), consumerKey, consumerSecret);
var authorizeUri = oauth.GetAuthorizeUri(new Uri(DropboxRestApi.AuthorizeBaseUri), requestToken);
Process.Start(authorizeUri.AbsoluteUri);
return oauth.GetAccessToken(new Uri(DropboxRestApi.BaseUri), consumerKey, consumerSecret, requestToken);
}
and here is the complete oauth function that is called when the registration button is clicked:
var accesstoken = GetAccessToken();

You need to make the Async (asynchronous) version of their GetAccessToken call. One that will call some function of yours when it is complete.
You could also loop until the information is ready, e.g.
while (dataIsNotReady()) {
Thread.Sleep(1000); // sleep for a bit. this is bad, locks up entire thread maybe even application while it sleeps. Make it shorter for less impact.
// TODO add a "timeout", i.e. only try this for X amount of time before breaking out
}
// Now we data is ready let's go
Update:
Perhaps you are better off using a library that can do it async for you e.g. this Dropbox C# library: https://github.com/dkarzon/DropNet