NSConnection - how to properly do "unvending" of an object?

Question

For Mac OSX, I'm trying to use an NSConnection to proxy access of an object from one application instance to another on the same host. The relevant code is below. I can provide more if needed. Assume when I say "server", I'm referring to the application that actually "vends" an object with an NSConnection. And "client" is the other instance of the same application that gets a proxy to it.

Everything works, except for two issues.

When an application acting as a server attempts to tear down the object it is vending, any client connected through a proxy still remains. That is, even after I call my stopLocalServer function below, any client app that previously connected and got a proxy object is still able to send messages and invoke code on the server app. I would have expected the client to throw an exception when passing a message after the server calls NSConnection:invalidate. How do I forcibly disconnect any client without requiring the server process to exit?
In the startClientConnection code below, if the server never vended the object in the first place with the expected registered name, then the call on the client to NSConnection:connectionWithRegisteredName:host will immediately return nil. This is good. But if the server had started vending an object via the startLocalServer code below, then later stops vending it with stopLocalServer, subsequent client attempts to connect will hang (block forever) until the server application process exits. The call to NSConnection:connectionWithRegisteredName returns a non-nil object, but the call to [_clientConnection rootProxy] hangs forever until the server application actually exits.

I suspect that I'm not properly tearing down the original NSConnection object or I'm missing something basic here.

Here is some relevant code for the platform that my user interface code sits on top of:

-(void)startLocalServer:(NSString*)str
{
    [self stopLocalServer];  // clean up any previous instance that might be running
    _serverConnection = [NSConnection new];
    [_serverConnection setRootObject:self];
    [_serverConnection registerName:str];
}
-(void)stopLocalServer
{
    [_serverConnection registerName:nil];
    [_serverConnection setRootObject:nil];
    [_serverConnection invalidate];
    _serverConnection = nil;
}

-(void)startClientConnection:(NSString*)str
{
    [self stopClientConnection];  // tear down any previous connection

    _clientConnection = [NSConnection connectionWithRegisteredName:str host:nil];

    if ((_clientConnection == nil) || (_clientConnection.valid == NO))
    {
        LogEvent(@"ERROR - _clientConnection is nil or invalid!");
    }
    else
    {
        _proxy = [_clientConnection rootProxy];
    }
}

-(void)stopClientConnection
{
    _proxy = nil;
    [_clientConnection invalidate];
    _clientConnection = nil;
}

In order for the client not hang as you've described a timeout would normally be set, which could be associated with an observer such as `NSConnectionDidDieNotification`. — l'L'l, Jul 05 '15 at 05:16
Good idea. And in production code both timeouts and try/catch blocks are a must have for working with NSConnection code. Timeouts won't resolve #1. But I think I figured out an answer that satisfies #1 and #2. — selbie, Jul 05 '15 at 09:24

selbie · Accepted Answer · 2015-07-11T18:47:45.073

Answering my own question. I'll still hold out for a better answer, or if anyone can do a better job explaining the reasoning about why this is needed.

I believe the stopLocalServer function needs to call [[_serverConnection receivePort] invalidate] such that the port created with the connection is closed. Just adding that line to the original stopLocalServer function solves my problem. That prevents further connection attempts and messages from succeeding.

More appropriately, the application call can just own the port that the NSConnection uses. So this becomes a better solution for starting and stopping a distributed object listener:

-(void)startLocalServer:(NSString*)str
{
    [self stopLocalServer];  // clean up any previous instance that might be running
    _port = [NSPort port];   // _port is of type NSPort*
    _serverConnection = [NSConnection connectionWithReceivePort:_port sendPort:nil];
    [_serverConnection setRootObject:self];
    [_serverConnection registerName:str];
}


-(void)stopLocalServer
{
    [_serverConnection registerName:nil];
    [_serverConnection setRootObject:nil];
    [_serverConnection invalidate];
    _serverConnection = nil;

    [_port invalidate];
    _port = nil;
}

That seems to solve both #1 and #2 above.

Personally, I'd invalidate the connection first and then the port. Invalidating the port out from under the connection seems like a bad idea. Also, note that the docs for `-registerName:` say that only `NSSocketPort`-based connections support unregistering. Another approach might be to use the `NSConnectionDelegate` methods plus observing `NSConnectionDidDieNotification` to keep track of the sub-connections spawned from your connection and invalidate those when you stop the server. — Ken Thomases, Jul 05 '15 at 17:23

NSConnection - how to properly do "unvending" of an object?

1 Answers1