Add/Delete Nodes

gistfile1.m

- (void)saveButtonPressed:(id)sender {
    // we need to compare the previousNodoes list to the current nodes list so we
    // can know which nodes to add and which ones to delete
    NSMutableArray *nodesToAdd = [[NSMutableArray alloc] init];
    NSMutableArray *nodesToDelete = [[NSMutableArray alloc] init];

    NSLog(@"previous nodes: %@", previousNodes);
    NSLog(@"lb nodes: %@", self.loadBalancer.nodes);
    
    for (LoadBalancerNode *node in previousNodes) {
        if (![self.loadBalancer.nodes containsObject:node]) {
            [nodesToDelete addObject:node];
            NSLog(@"going to delete node: %@", node);
        }
    }
    
    for (LoadBalancerNode *node in self.loadBalancer.nodes) {
        if (![previousNodes containsObject:node]) {
            [nodesToAdd addObject:node];
            NSLog(@"going to add node: %@", node);
        }
    }
    
    // make the API calls
    ActivityIndicatorView *spinner = [[ActivityIndicatorView alloc] initWithFrame:[ActivityIndicatorView frameForText:@"Saving..." withProgress:YES] text:@"Saving..." withProgress:YES];
    [spinner addToView:self.view];
    
    NSString *endpoint = [self.account loadBalancerEndpointForRegion:self.loadBalancer.region];    
    NSInteger totalAPICalls = [nodesToDelete count] + ([nodesToAdd count] > 0 ? 1 : 0);
    __block NSInteger currentAPICalls = 0;
    __block int deleteIndex = 0;

    ASIBasicBlock spinnerBlock = ^{
        currentAPICalls++;
        if (currentAPICalls == totalAPICalls) {
            [spinner removeFromSuperviewAndRelease]; 
        }
    };
    
    void (^deleteNodeBlock)(LoadBalancerNode *node) = ^(LoadBalancerNode *node) {
        APICallback *callback = [self.account.manager deleteLBNode:node loadBalancer:self.loadBalancer endpoint:endpoint];
        [callback success:^(OpenStackRequest *request) {
            deleteIndex++;
            spinnerBlock();
            if (deleteIndex < [nodesToDelete count]) {
                [self.loadBalancer pollUntilActive:self.account complete:^{
                    deleteNodeBlock([nodesToDelete objectAtIndex:deleteIndex]);
                }];
            }
        } failure:^(OpenStackRequest *request) {
            deleteIndex++;
            spinnerBlock();
            if (deleteIndex < [nodesToDelete count]) {
                [self.loadBalancer pollUntilActive:self.account complete:^{
                    deleteNodeBlock([nodesToDelete objectAtIndex:deleteIndex]);
                }];
            }
            [self alert:@"There was a problem deleting a node." request:request];
        }];
    };
    
    ASIBasicBlock deleteNodesBlock = ^{
        LoadBalancerNode *node = [nodesToDelete objectAtIndex:deleteIndex];
        deleteNodeBlock(node);
    };

    if ([nodesToAdd count] > 0) {
        // we want to add before doing any deletes to avoid attempting an invalid delete
        APICallback *callback = [self.account.manager addLBNodes:nodesToAdd loadBalancer:self.loadBalancer endpoint:endpoint];
        [callback success:^(OpenStackRequest *request) {
            spinnerBlock();
            
            // if it's a successful add, the status will be PENDING_UPDATE.  cheaper
            // to just set it than hit the API again since we're already going to hit it
            // n times for the deletes
            self.loadBalancer.status = @"PENDING_UPDATE";
            
            // before you delete, you need to poll the LB until it hits active status
            [self.loadBalancer pollUntilActive:self.account complete:^{
                deleteNodesBlock();
            }];
            
        } failure:^(OpenStackRequest *request) {
            [self alert:@"There was a problem adding nodes." request:request];
            [spinner removeFromSuperviewAndRelease];
        }];
    } else {
        deleteNodesBlock();
    }
    
    [nodesToAdd release];
    [nodesToDelete release];
}