Synnefo » Pithos MacOS Client

//

//  PithosBrowserController.m

//  pithos-macos

//

// Copyright 2011-2013 GRNET S.A. All rights reserved.

//

// Redistribution and use in source and binary forms, with or

// without modification, are permitted provided that the following

// conditions are met:

// 

//   1. Redistributions of source code must retain the above

//      copyright notice, this list of conditions and the following

//      disclaimer.

// 

//   2. Redistributions in binary form must reproduce the above

//      copyright notice, this list of conditions and the following

//      disclaimer in the documentation and/or other materials

//      provided with the distribution.

// 

// THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

// OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

// USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

// POSSIBILITY OF SUCH DAMAGE.

// 

// The views and conclusions contained in the software and

// documentation are those of the authors and should not be

// interpreted as representing official policies, either expressed

// or implied, of GRNET S.A.

#import "PithosBrowserController.h"

#import "PithosNode.h"

#import "PithosAccountNode.h"

#import "PithosContainerNode.h"

#import "PithosSubdirNode.h"

#import "PithosObjectNode.h"

#import "PithosSharingAccountsNode.h"

#import "PithosEmptyNode.h"

#import "ImageAndTextCell.h"

#import "FileSystemBrowserCell.h"

#import "ASINetworkQueue.h"

#import "ASIPithosRequest.h"

#import "ASIPithos.h"

#import "ASIPithosContainerRequest.h"

#import "ASIPithosObjectRequest.h"

#import "ASIPithosAccount.h"

#import "ASIPithosContainer.h"

#import "ASIPithosObject.h"

#import "PithosUtilities.h"

#import "PithosAccount.h"

#import "UsingSizeTransformer.h"

#define REFRESH_TIMER_INTERVAL 5

@interface PithosBrowserCell : FileSystemBrowserCell {}

@end

@implementation PithosBrowserCell

- (id)init {

    if ((self = [super init])) {

        [self setLineBreakMode:NSLineBreakByTruncatingMiddle];

        [self setEditable:YES];

    }

    return self;

}

- (void)setObjectValue:(id)object {

    if ([object isKindOfClass:[PithosNode class]]) {

        PithosNode *node = (PithosNode *)object;

        [self setStringValue:node.displayName];

        [self setImage:node.icon];

    } else {

        [super setObjectValue:object];

    }

}

@end

@interface PithosOutlineViewCell : ImageAndTextCell {}

@end

@implementation PithosOutlineViewCell

- (void)setObjectValue:(id)object {

    if ([object isKindOfClass:[PithosNode class]]) {

        PithosNode *node = (PithosNode *)object;

        [self setStringValue:node.displayName];

        [self setImage:node.icon];

        [self setEditable:NO];

    } else {

        [super setObjectValue:object];

    }

}

@end

@interface PithosBrowserController (Private)

- (BOOL)uploadFiles:(NSArray *)filenames toNode:(PithosNode *)destinationNode;

- (BOOL)moveNodes:(NSArray *)nodes toNode:(PithosNode *)destinationNode;

- (BOOL)cpyNodes:(NSArray *)nodes toNode:(PithosNode *)destinationNode;

@end

@implementation PithosBrowserController

@synthesize pithosAccountManager, accountNode;

@synthesize draggedNodes, draggedParentNode;

@synthesize clipboardNodes, clipboardParentNode, clipboardCopy;

#pragma mark -

#pragma Object Lifecycle

- (id)init {

    return [super initWithWindowNibName:@"PithosBrowserController"];

}

- (void)windowDidLoad {

    [super windowDidLoad];

    if (browser && !browserInitialized) {

        browserInitialized = YES;

        [self initBrowser];

    }

}

- (void)initBrowser {

    [browser registerForDraggedTypes:[NSArray arrayWithObjects:NSFilenamesPboardType, NSFilesPromisePboardType, nil]];

    [browser setDraggingSourceOperationMask:(NSDragOperationCopy|NSDragOperationMove) forLocal:YES];

    [browser setDraggingSourceOperationMask:NSDragOperationCopy forLocal:NO];

    [outlineView registerForDraggedTypes:[NSArray arrayWithObjects:NSFilenamesPboardType, NSFilesPromisePboardType, nil]];

    [outlineView setDraggingSourceOperationMask:(NSDragOperationCopy|NSDragOperationMove) forLocal:YES];

    [outlineView setDraggingSourceOperationMask:NSDragOperationCopy forLocal:NO];

    [browser setCellClass:[PithosBrowserCell class]];

    [browser setAllowsBranchSelection:YES];

    [browser setAllowsMultipleSelection:YES];

    [browser setAllowsEmptySelection:YES];

    [browser setAllowsTypeSelect:YES];

    [browser setDoubleAction:@selector(browserDoubleAction:)];

    moveNetworkQueue = [[ASINetworkQueue alloc] init];

    moveNetworkQueue.shouldCancelAllRequestsOnFailure = NO;

//    moveNetworkQueue.maxConcurrentOperationCount = 1;

    copyNetworkQueue = [[ASINetworkQueue alloc] init];

    copyNetworkQueue.shouldCancelAllRequestsOnFailure = NO;

//    copyNetworkQueue.maxConcurrentOperationCount = 1;

    deleteNetworkQueue = [[ASINetworkQueue alloc] init];

    deleteNetworkQueue.shouldCancelAllRequestsOnFailure = NO;

//    deleteNetworkQueue.maxConcurrentOperationCount = 1;

    uploadNetworkQueue = [[ASINetworkQueue alloc] init];

    uploadNetworkQueue.showAccurateProgress = YES;

    uploadNetworkQueue.shouldCancelAllRequestsOnFailure = NO;

//    uploadNetworkQueue.maxConcurrentOperationCount = 1;

    downloadNetworkQueue = [[ASINetworkQueue alloc] init];

    downloadNetworkQueue.showAccurateProgress = YES;

    downloadNetworkQueue.shouldCancelAllRequestsOnFailure = NO;

//    downloadNetworkQueue.maxConcurrentOperationCount = 1;

    moveQueue = [[NSOperationQueue alloc] init];

    [moveQueue setSuspended:YES];

    moveQueue.name = @"gr.grnet.pithos.MoveQueue";

//    moveQueue.maxConcurrentOperationCount = 1;

    copyQueue = [[NSOperationQueue alloc] init];

    [copyQueue setSuspended:YES];

    copyQueue.name = @"gr.grnet.pithos.CopyQueue";

//    copyQueue.maxConcurrentOperationCount = 1;

    deleteQueue = [[NSOperationQueue alloc] init];

    [deleteQueue setSuspended:YES];

    deleteQueue.name = @"gr.grnet.pithos.DeleteQueue";

//    deleteQueue.maxConcurrentOperationCount = 1;

    uploadQueue = [[NSOperationQueue alloc] init];

    [uploadQueue setSuspended:YES];

    uploadQueue.name = @"gr.grnet.pithos.UploadQueue";

//    uploadQueue.maxConcurrentOperationCount = 1;

    downloadQueue = [[NSOperationQueue alloc] init];

    [downloadQueue setSuspended:YES];

    downloadQueue.name = @"gr.grnet.pithos.DownloadQueue";

//    downloadQueue.maxConcurrentOperationCount = 1;

    moveCallbackQueue = [[NSOperationQueue alloc] init];

    [moveCallbackQueue setSuspended:YES];

    moveCallbackQueue.name = @"gr.grnet.pithos.MoveCallbackQueue";

//    moveCallbackQueue.maxConcurrentOperationCount = 1;

    copyCallbackQueue = [[NSOperationQueue alloc] init];

    [copyCallbackQueue setSuspended:YES];

    copyCallbackQueue.name = @"gr.grnet.pithos.CopyCallbackQueue";

//    copyCallbackQueue.maxConcurrentOperationCount = 1;

    deleteCallbackQueue = [[NSOperationQueue alloc] init];

    [deleteCallbackQueue setSuspended:YES];

    deleteCallbackQueue.name = @"gr.grnet.pithos.DeleteCallbackQueue";

//    deleteCallbackQueue.maxConcurrentOperationCount = 1;

    uploadCallbackQueue = [[NSOperationQueue alloc] init];

    [uploadCallbackQueue setSuspended:YES];

    uploadCallbackQueue.name = @"gr.grnet.pithos.UploadCallbackQueue";

//    uploadCallbackQueue.maxConcurrentOperationCount = 1;

    downloadCallbackQueue = [[NSOperationQueue alloc] init];

    [downloadCallbackQueue setSuspended:YES];

    downloadCallbackQueue.name = @"gr.grnet.pithos.DownloadCallbackQueue";

//    downloadCallbackQueue.maxConcurrentOperationCount = 1;

    [activityProgressIndicator setUsesThreadedAnimation:YES];

    [activityProgressIndicator setMinValue:0.0];

    [activityProgressIndicator setMaxValue:1.0];

    activityFacility = [PithosActivityFacility defaultPithosActivityFacility];

    self.accountNode = [[PithosAccountNode alloc] initWithPithosAccountManager:pithosAccountManager];

    containersNode = [[PithosEmptyNode alloc] initWithDisplayName:@"CONTAINERS" icon:nil];

    containersNodeChildren = [[NSMutableArray alloc] init];

    sharedNode = [[PithosEmptyNode alloc] initWithDisplayName:@"SHARED" icon:nil];

    mySharedNode = [[PithosAccountNode alloc] initWithPithosAccountManager:pithosAccountManager];

    mySharedNode.displayName = @"shared by me";

    mySharedNode.shared = YES;

    mySharedNode.icon = [[NSWorkspace sharedWorkspace] iconForFileType:NSFileTypeForHFSTypeCode(kUserIcon)];

    othersSharedNode = [[PithosSharingAccountsNode alloc] initWithPithosAccountManager:pithosAccountManager];

    othersSharedNode.displayName = @"shared with me";

    othersSharedNode.icon = [[NSWorkspace sharedWorkspace] iconForFileType:NSFileTypeForHFSTypeCode(kGroupIcon)];

    [[[outlineView tableColumns] objectAtIndex:0] setDataCell:[[PithosOutlineViewCell alloc] init]];

    // Register for updates

    // PithosAccountNode accountNode updates outlineView container nodes 

    [[NSNotificationCenter defaultCenter] addObserver:self 

                                             selector:@selector(pithosAccountNodeChildrenUpdated:) 

                                                 name:@"PithosNodeChildrenUpdated" 

                                               object:accountNode];

    // PithosNode updates browser nodes

    [[NSNotificationCenter defaultCenter] addObserver:self 

                                             selector:@selector(pithosNodeChildrenUpdated:) 

                                                 name:@"PithosNodeChildrenUpdated" 

                                               object:nil];

    // Request for browser refresh 

    [[NSNotificationCenter defaultCenter] addObserver:self 

                                             selector:@selector(pithosBrowserRefreshNeeded:) 

                                                 name:@"PithosBrowserRefreshNeeded" 

                                               object:nil];

}

- (void)resetBrowser {

    @synchronized(self) {

        if (!browserActive)

            return;

    }

    [refreshTimer invalidate];

    [moveNetworkQueue reset];

    [copyNetworkQueue reset];

    [deleteNetworkQueue reset];

    [uploadNetworkQueue reset];

    [downloadNetworkQueue reset];

    [moveQueue cancelAllOperations];

    [moveQueue setSuspended:YES];

    [copyQueue cancelAllOperations];

    [copyQueue setSuspended:YES];

    [deleteQueue cancelAllOperations];

    [deleteQueue setSuspended:YES];

    [uploadQueue cancelAllOperations];

    [uploadQueue setSuspended:YES];

    [downloadQueue cancelAllOperations];

    [downloadQueue setSuspended:YES];

    [moveCallbackQueue cancelAllOperations];

    [moveCallbackQueue setSuspended:YES];

    [copyCallbackQueue cancelAllOperations];

    [copyCallbackQueue setSuspended:YES];

    [deleteCallbackQueue cancelAllOperations];

    [deleteCallbackQueue setSuspended:YES];

    [uploadCallbackQueue cancelAllOperations];

    [uploadCallbackQueue setSuspended:YES];

    [downloadCallbackQueue cancelAllOperations];

    [downloadCallbackQueue setSuspended:YES];

    [accountNode pithosNodeWillBeRemoved];

    [mySharedNode pithosNodeWillBeRemoved];

    [othersSharedNode pithosNodeWillBeRemoved];

    rootNode = nil;

    [browser loadColumnZero];

    [containersNodeChildren removeAllObjects];

    [outlineView reloadData];

    // Expand the folder outline view

    [outlineView expandItem:nil expandChildren:YES];

    [outlineView selectRowIndexes:[NSIndexSet indexSetWithIndex:1] byExtendingSelection:NO];

    activityFacility.delegate = nil;

    [activityProgressIndicator setDoubleValue:1.0];

    [activityProgressIndicator stopAnimation:self];

    @synchronized(self) {

        browserActive = NO;

    }

}

- (void)startBrowser {

    @synchronized(self) {

        if (browserActive)

            return;

    }

    // In the improbable case of leftover operations

    [moveNetworkQueue reset];

    [copyNetworkQueue reset];

    [deleteNetworkQueue reset];

    [uploadNetworkQueue reset];

    [downloadNetworkQueue reset];

    [moveQueue cancelAllOperations];

    [copyQueue cancelAllOperations];

    [deleteQueue cancelAllOperations];

    [uploadQueue cancelAllOperations];

    [downloadQueue cancelAllOperations];

    [moveCallbackQueue cancelAllOperations];

    [copyCallbackQueue cancelAllOperations];

    [deleteCallbackQueue cancelAllOperations];

    [uploadCallbackQueue cancelAllOperations];

    [downloadCallbackQueue cancelAllOperations];

    [moveNetworkQueue go];

    [copyNetworkQueue go];

    [deleteNetworkQueue go];

    [uploadNetworkQueue go];

    [downloadNetworkQueue go];

    [moveQueue setSuspended:NO];

    [copyQueue setSuspended:NO];

    [deleteQueue setSuspended:NO];

    [uploadQueue setSuspended:NO];

    [downloadQueue setSuspended:NO];

    [moveCallbackQueue setSuspended:NO];

    [copyCallbackQueue setSuspended:NO];

    [deleteCallbackQueue setSuspended:NO];

    [uploadCallbackQueue setSuspended:NO];

    [downloadCallbackQueue setSuspended:NO];

    accountNode.pithosAccountManager = pithosAccountManager;

    [accountNode reset];

    mySharedNode.pithosAccountManager = pithosAccountManager;

    [mySharedNode reset];

    othersSharedNode.pithosAccountManager = pithosAccountManager;

    [othersSharedNode reset];

//    [activityFacility reset];

    activityFacility.delegate = self;

    refreshTimer = [NSTimer scheduledTimerWithTimeInterval:REFRESH_TIMER_INTERVAL 

                                                     target:self 

                                                   selector:@selector(forceRefresh:) 

                                                   userInfo:self 

                                                    repeats:YES];

    @synchronized(self) {

        browserActive = YES;

    }

}

- (BOOL)operationsPending {

    return ([moveNetworkQueue operationCount] || 

            [copyNetworkQueue operationCount] || 

            [deleteNetworkQueue operationCount] || 

            [uploadNetworkQueue operationCount] || 

            [downloadNetworkQueue operationCount] || 

            [moveQueue operationCount] || 

            [copyQueue operationCount] || 

            [deleteQueue operationCount] || 

            [uploadQueue operationCount] || 

            [downloadQueue operationCount] || 

            [moveCallbackQueue operationCount] || 

            [copyCallbackQueue operationCount] || 

            [deleteCallbackQueue operationCount] || 

            [uploadCallbackQueue operationCount] || 

            [downloadCallbackQueue operationCount]);

}

- (void)dealloc {

    [[NSNotificationCenter defaultCenter] removeObserver:self];

    [self resetBrowser];

}

- (void)setPithosAccountManager:(PithosAccount *)aPithosAccountManager {

    if (aPithosAccountManager && (aPithosAccountManager != pithosAccountManager)) {

        [self resetBrowser];

        if (pithosAccountManager)

            [[NSNotificationCenter defaultCenter] removeObserver:self name:@"PithosAccountPithosChanged" object:pithosAccountManager];

        pithosAccountManager = aPithosAccountManager;

        [[NSNotificationCenter defaultCenter] addObserver:self

                                                 selector:@selector(pithosAccountManagerPithosChanged:)

                                                     name:@"PithosAccountPithosChanged"

                                                   object:pithosAccountManager];

        [self startBrowser];

    }

}

#pragma mark -

#pragma mark Observers

-(void)pithosAccountManagerPithosChanged:(NSNotification *)notification {

    if (![NSThread isMainThread]) {

        [self performSelectorOnMainThread:@selector(pithosAccountManagerPithosChanged:) withObject:notification waitUntilDone:NO];

        return;

    }

    [self resetBrowser];

    [self startBrowser];

}

- (void)pithosNodeChildrenUpdated:(NSNotification *)notification {

    if (![NSThread isMainThread]) {

        [self performSelectorOnMainThread:@selector(pithosNodeChildrenUpdated:) withObject:notification waitUntilDone:NO];

        return;

    }

    PithosNode *node = (PithosNode *)[notification object];

    if ((node == accountNode) || (node.pithosAccountManager != pithosAccountManager))

        return;

    DLog(@"pithosNodeChildrenUpdated:%@", node.url);

    NSInteger lastColumn = [browser lastColumn];

    for (NSInteger column = lastColumn; column >= 0; column--) {

        if ([[browser parentForItemsInColumn:column] isEqualTo:node]) {

            [browser reloadColumn:column];

            return;

        }

    }

}

- (void)pithosAccountNodeChildrenUpdated:(NSNotification *)notification {

    if (![NSThread isMainThread]) {

        [self performSelectorOnMainThread:@selector(pithosAccountNodeChildrenUpdated:) withObject:notification waitUntilDone:NO];

        return;

    }

    BOOL containerPithosFound = NO;

    BOOL containerTrashFound = NO;

    NSMutableIndexSet *removedContainersNodeChildren = [NSMutableIndexSet indexSet];

    for (NSUInteger i = 0 ; i < [containersNodeChildren count] ; i++) {

        if (![accountNode.children containsObject:[containersNodeChildren objectAtIndex:i]])

            [removedContainersNodeChildren addIndex:i];

    }

    [containersNodeChildren removeObjectsAtIndexes:removedContainersNodeChildren];

    for (PithosContainerNode *containerNode in accountNode.children) {

        if ([containerNode.pithosContainer.name isEqualToString:@"pithos"]) {

            if (![containersNodeChildren containsObject:containerNode])

                [containersNodeChildren insertObject:containerNode atIndex:0];

            containerPithosFound = YES;

        } else if ([containerNode.pithosContainer.name isEqualToString:@"trash"]) {

            NSUInteger insertIndex = 1;

            if (!containerPithosFound)

                insertIndex = 0;

            if (![containersNodeChildren containsObject:containerNode])

                [containersNodeChildren insertObject:containerNode atIndex:insertIndex];

            containerTrashFound = YES;

        } else if (![containersNodeChildren containsObject:containerNode]) {

            [containersNodeChildren addObject:containerNode];

        }

    }

    BOOL refreshAccountNode = NO;

    if (!containerPithosFound) {

        // Create pithos node

        ASIPithosContainerRequest *containerRequest = [ASIPithosContainerRequest createOrUpdateContainerRequestWithPithos:pithosAccountManager.pithos

                                                                                                            containerName:@"pithos"];

        [PithosUtilities startAndWaitForRequest:containerRequest];

        if ([containerRequest error]) {

            [PithosUtilities httpRequestErrorAlertWithRequest:containerRequest];

        } else {

            refreshAccountNode = YES;

        }

    }

    if (!containerTrashFound) {

        // Create trash node

        ASIPithosContainerRequest *containerRequest = [ASIPithosContainerRequest createOrUpdateContainerRequestWithPithos:pithosAccountManager.pithos 

                                                                                                            containerName:@"trash"];

        [PithosUtilities startAndWaitForRequest:containerRequest];

        if ([containerRequest error]) {

            [PithosUtilities httpRequestErrorAlertWithRequest:containerRequest];

        } else {

            refreshAccountNode = YES;

        }

    }

    if (refreshAccountNode)

        [accountNode refresh];

    [outlineView reloadData];

    // Expand the folder outline view

    [outlineView expandItem:nil expandChildren:YES];

    if (((rootNode == nil) || (rootNode == containersNode) || (rootNode == sharedNode)) && [containersNodeChildren count]) {

        rootNode = [containersNodeChildren objectAtIndex:0];

        [browser loadColumnZero];

    }

    if (notification)

        [self refresh:nil];

}

- (void)pithosBrowserRefreshNeeded:(NSNotification *)notification {

    [self refresh:nil];

}

#pragma mark -

#pragma mark Actions

- (IBAction)forceRefresh:(id)sender {

    if (![NSThread isMainThread]) {

        [self performSelectorOnMainThread:@selector(forceRefresh:) withObject:sender waitUntilDone:NO];

        return;

    }

    if (editingItem)

        return;

    if (sender)

        [accountNode forceRefresh];

    for (NSInteger column = [browser lastColumn]; column >= 0; column--) {

        PithosNode *node = (PithosNode *)[browser parentForItemsInColumn:column];

        node.forcedRefresh = YES;

        [(PithosNode *)[browser parentForItemsInColumn:column] invalidateChildren];                      

    }

    [browser validateVisibleColumns];

}

- (IBAction)refresh:(id)sender {

    if (![NSThread isMainThread]) {

        [self performSelectorOnMainThread:@selector(refresh:) withObject:sender waitUntilDone:NO];

        return;

    }

    if (editingItem)

        return;

    if ([[NSApp currentEvent] modifierFlags] & NSShiftKeyMask) {

        [self forceRefresh:sender];

    } else {

        if (sender)

            [accountNode refresh];

        for (NSInteger column = [browser lastColumn]; column >= 0; column--) {

            [(PithosNode *)[browser parentForItemsInColumn:column] invalidateChildren];

        }

        [browser validateVisibleColumns];

    }

}

#pragma mark -

#pragma mark NSBrowserDelegate

- (id)rootItemForBrowser:(NSBrowser *)browser {

    return rootNode;    

}

- (NSInteger)browser:(NSBrowser *)browser numberOfChildrenOfItem:(id)item {

    PithosNode *node = (PithosNode *)item;

    return node.children.count;

}

- (id)browser:(NSBrowser *)browser child:(NSInteger)index ofItem:(id)item {

    PithosNode *node = (PithosNode *)item;

    return [node.children objectAtIndex:index];

}

- (BOOL)browser:(NSBrowser *)browser isLeafItem:(id)item {

    PithosNode *node = (PithosNode *)item;

    return node.isLeafItem;

}

- (id)browser:(NSBrowser *)browser objectValueForItem:(id)item {

    PithosNode *node = (PithosNode *)item;

    return node;

}

- (NSViewController *)browser:(NSBrowser *)browser previewViewControllerForLeafItem:(id)item {

    if (sharedPreviewController == nil)

        sharedPreviewController = [[NSViewController alloc] initWithNibName:@"PithosBrowserPreviewController" bundle:[NSBundle bundleForClass:[self class]]];

    return sharedPreviewController;

}

//- (CGFloat)browser:(NSBrowser *)browser shouldSizeColumn:(NSInteger)columnIndex forUserResize:(BOOL)forUserResize toWidth:(CGFloat)suggestedWidth  {

//    if (!forUserResize) {

//        id item = [browser parentForItemsInColumn:columnIndex]; 

//        if ([self browser:browser isLeafItem:item]) {

//            suggestedWidth = 200; 

//        }

//    }

//    return suggestedWidth;

//}

- (BOOL)browser:(NSBrowser *)sender isColumnValid:(NSInteger)column {

    return NO;

}

#pragma mark Editing

- (BOOL)browser:(NSBrowser *)browser shouldEditItem:(id)item {

    PithosNode *node = (PithosNode *)item;

    if (node.shared || node.sharingAccount || 

        ([node class] == [PithosContainerNode class]) || ([node class] == [PithosAccountNode class]))

        return NO;

    editingItem = YES;

    return YES;

}

- (void)browser:(NSBrowser *)browser setObjectValue:(id)object forItem:(id)item {

    editingItem = NO;

    PithosNode *node = (PithosNode *)item;

    NSString *newName = (NSString *)object;

    NSUInteger newNameLength = [newName length];

    NSRange firstSlashRange = [newName rangeOfString:@"/"];

    if ((newNameLength == 0) || 

        ((firstSlashRange.length == 1) && (firstSlashRange.location != (newNameLength - 1))) || 

        ([newName isEqualToString:node.displayName])) {

        return;

    }

    if (([node class] == [PithosObjectNode class]) || 

        (([node class] == [PithosSubdirNode class]) && !node.pithosObject.subdir && [node.pithosObject.name hasSuffix:@"/"])) {

        // Operation: Rename (move) an object or subdir/ node

        __block NSOperation *operation = [NSBlockOperation blockOperationWithBlock:^{

            @autoreleasepool {

                if (operation.isCancelled)

                    return;

                NSString *destinationObjectName = [[node.pithosObject.name stringByDeletingLastPathComponent] stringByAppendingPathComponent:newName];

                if ([newName hasSuffix:@"/"])

                    destinationObjectName = [destinationObjectName stringByAppendingString:@"/"];

                NSError *error = nil;

                BOOL isDirectory;

                if ([PithosUtilities objectExistsAtPithos:pithosAccountManager.pithos

                                            containerName:node.pithosContainer.name 

                                               objectName:destinationObjectName 

                                                    error:&error 

                                              isDirectory:&isDirectory 

                                           sharingAccount:nil]) {

                    dispatch_async(dispatch_get_main_queue(), ^{

                        NSAlert *alert = [[NSAlert alloc] init];

                        [alert setMessageText:@"Name Taken"];

                        [alert setInformativeText:[NSString stringWithFormat:@"The name '%@' is already taken. Please choose a different name", newName]];

                        [alert addButtonWithTitle:@"OK"];

                        [alert runModal];

                    });

                    return;

                } else if (error) {

                    return;

                }

                if (operation.isCancelled)

                    return;

                ASIPithosObjectRequest *objectRequest = [PithosUtilities moveObjectRequestWithPithos:pithosAccountManager.pithos

                                                                                       containerName:node.pithosContainer.name 

                                                                                          objectName:node.pithosObject.name 

                                                                            destinationContainerName:node.pithosContainer.name 

                                                                               destinationObjectName:destinationObjectName 

                                                                                       checkIfExists:NO];

                if (!operation.isCancelled && objectRequest) {

                    objectRequest.delegate = self;

                    objectRequest.didFinishSelector = @selector(performRequestFinishedDelegateInBackground:);

                    objectRequest.didFailSelector = @selector(performRequestFailedDelegateInBackground:);

                    NSString *messagePrefix = [NSString stringWithFormat:@"Moving '%@/%@' to '%@/%@'", 

                                               [objectRequest.userInfo objectForKey:@"sourceContainerName"], 

                                               [objectRequest.userInfo objectForKey:@"sourceObjectName"], 

                                               [objectRequest.userInfo objectForKey:@"destinationContainerName"], 

                                               [objectRequest.userInfo objectForKey:@"destinationObjectName"]];

                    PithosActivity *activity = [activityFacility startActivityWithType:PithosActivityMove 

                                                                               message:messagePrefix];

                    [(NSMutableDictionary *)(objectRequest.userInfo) addEntriesFromDictionary:

                     [NSDictionary dictionaryWithObjectsAndKeys:

                      [NSArray arrayWithObject:node.parent], @"forceRefreshNodes", 

                      [NSNumber numberWithBool:YES], @"refresh", 

                      activity, @"activity", 

                      [messagePrefix stringByAppendingString:@" (stopped)"], @"stoppedActivityMessage", 

                      [messagePrefix stringByAppendingString:@" (failed)"], @"failedActivityMessage", 

                      [messagePrefix stringByAppendingString:@" (finished)"], @"finishedActivityMessage", 

                      [NSNumber numberWithInteger:NSOperationQueuePriorityHigh], @"priority", 

                      [NSNumber numberWithUnsignedInteger:10], @"retries", 

                      NSStringFromSelector(@selector(moveFinished:)), @"didFinishSelector", 

                      NSStringFromSelector(@selector(requestFailed:)), @"didFailSelector", 

                      moveNetworkQueue, @"networkQueue", 

                      @"move", @"operationType", 

                      nil]];

                    [moveNetworkQueue addOperation:[PithosUtilities prepareRequest:objectRequest priority:NSOperationQueuePriorityHigh]];

                }

            }

        }];

        [moveQueue addOperation:operation];

    } else if ([node class] == [PithosSubdirNode class]) {

        if (firstSlashRange.length == 1)

            return;

        // Operation: Rename (move) a subdir node and its descendants

        // The resulting ASIPithosObjectRequests are chained through dependencies

        __block NSOperation *operation = [NSBlockOperation blockOperationWithBlock:^{

            @autoreleasepool {

                if (operation.isCancelled)

                    return;

                NSString *destinationObjectName = [[node.pithosObject.name stringByDeletingLastPathComponent] stringByAppendingPathComponent:newName];

                NSError *error = nil;

                BOOL isDirectory;

                if ([PithosUtilities objectExistsAtPithos:pithosAccountManager.pithos

                                            containerName:node.pithosContainer.name 

                                               objectName:destinationObjectName 

                                                    error:&error 

                                              isDirectory:&isDirectory 

                                           sharingAccount:nil]) {

                    dispatch_async(dispatch_get_main_queue(), ^{

                        NSAlert *alert = [[NSAlert alloc] init];

                        [alert setMessageText:@"Name Taken"];

                        [alert setInformativeText:[NSString stringWithFormat:@"The name '%@' is already taken. Please choose a different name", newName]];

                        [alert addButtonWithTitle:@"OK"];

                        [alert runModal];

                    });

                    return;

                } else if (error) {

                    return;

                }

                if (operation.isCancelled)

                    return;

                if (node.pithosObject.subdir)

                    destinationObjectName = [destinationObjectName stringByAppendingString:@"/"];

                NSArray *objectRequests = [PithosUtilities moveObjectRequestsForSubdirWithPithos:pithosAccountManager.pithos

                                                                                   containerName:node.pithosContainer.name 

                                                                                      objectName:node.pithosObject.name 

                                                                        destinationContainerName:node.pithosContainer.name 

                                                                           destinationObjectName:destinationObjectName 

                                                                                   checkIfExists:NO];

                if (!operation.isCancelled && objectRequests) {

                    ASIPithosObjectRequest *previousObjectRequest = nil;

                    for (ASIPithosObjectRequest *objectRequest in objectRequests) {

                        if (operation.isCancelled)

                            return;

                        objectRequest.delegate = self;

                        objectRequest.didFinishSelector = @selector(performRequestFinishedDelegateInBackground:);

                        objectRequest.didFailSelector = @selector(performRequestFailedDelegateInBackground:);

                        NSString *messagePrefix = [NSString stringWithFormat:@"Moving '%@/%@' to '%@/%@'", 

                                                   [objectRequest.userInfo objectForKey:@"sourceContainerName"], 

                                                   [objectRequest.userInfo objectForKey:@"sourceObjectName"], 

                                                   [objectRequest.userInfo objectForKey:@"destinationContainerName"], 

                                                   [objectRequest.userInfo objectForKey:@"destinationObjectName"]];

                        PithosActivity *activity = [activityFacility startActivityWithType:PithosActivityMove 

                                                                                   message:messagePrefix];

                        [(NSMutableDictionary *)(objectRequest.userInfo) addEntriesFromDictionary:

                         [NSDictionary dictionaryWithObjectsAndKeys:

                          [NSArray arrayWithObject:node.parent], @"forceRefreshNodes", 

                          [NSNumber numberWithBool:YES], @"refresh", 

                          activity, @"activity", 

                          [messagePrefix stringByAppendingString:@" (stopped)"], @"stoppedActivityMessage", 

                          [messagePrefix stringByAppendingString:@" (failed)"], @"failedActivityMessage", 

                          [messagePrefix stringByAppendingString:@" (finished)"], @"finishedActivityMessage", 

                          [NSNumber numberWithInteger:NSOperationQueuePriorityHigh], @"priority", 

                          [NSNumber numberWithUnsignedInteger:10], @"retries", 

                          NSStringFromSelector(@selector(moveFinished:)), @"didFinishSelector", 

                          NSStringFromSelector(@selector(requestFailed:)), @"didFailSelector", 

                          moveNetworkQueue, @"networkQueue", 

                          @"move", @"operationType", 

                          nil]];

                        if (previousObjectRequest)

                            [objectRequest addDependency:previousObjectRequest];

                        previousObjectRequest = objectRequest;

                        [moveNetworkQueue addOperation:[PithosUtilities prepareRequest:objectRequest priority:NSOperationQueuePriorityHigh]];

                    }

                }

            }

        }];

        [moveQueue addOperation:operation];

    }

}

#pragma mark Drag and Drop source

- (BOOL)browser:(NSBrowser *)aBrowser canDragRowsWithIndexes:(NSIndexSet *)rowIndexes inColumn:(NSInteger)column 

      withEvent:(NSEvent *)event {

    NSIndexPath *baseIndexPath = [browser indexPathForColumn:column];

    __block BOOL result = YES;

    [rowIndexes enumerateIndexesUsingBlock:^(NSUInteger idx, BOOL *stop){

        PithosNode *node = [browser itemAtIndexPath:[baseIndexPath indexPathByAddingIndex:idx]];

        if (([node class] == [PithosContainerNode class]) || ([node class] == [PithosAccountNode class])) {

            result = NO;

            *stop = YES;

        }

    }];

    return result;

}

- (BOOL)browser:(NSBrowser *)aBrowser writeRowsWithIndexes:(NSIndexSet *)rowIndexes inColumn:(NSInteger)column 

   toPasteboard:(NSPasteboard *)pasteboard {

    NSMutableArray *propertyList = [NSMutableArray arrayWithCapacity:[rowIndexes count]];

    NSMutableArray *nodes = [NSMutableArray arrayWithCapacity:[rowIndexes count]];

    NSIndexPath *baseIndexPath = [browser indexPathForColumn:column];

    [rowIndexes enumerateIndexesUsingBlock:^(NSUInteger idx, BOOL *stop){

        PithosNode *node = [browser itemAtIndexPath:[baseIndexPath indexPathByAddingIndex:idx]];

        [propertyList addObject:[node.pithosObject.name pathExtension]];

        [nodes addObject:node];

    }];

    [pasteboard declareTypes:[NSArray arrayWithObject:NSFilesPromisePboardType] owner:self];

    [pasteboard setPropertyList:propertyList forType:NSFilesPromisePboardType];

    self.draggedNodes = nodes;

    self.draggedParentNode = [browser parentForItemsInColumn:column];

    return YES;

}

- (NSArray *)browser:(NSBrowser *)aBrowser namesOfPromisedFilesDroppedAtDestination:(NSURL *)dropDestination 

forDraggedRowsWithIndexes:(NSIndexSet *)rowIndexes inColumn:(NSInteger)column {

    NSMutableArray *names = [NSMutableArray arrayWithCapacity:[draggedNodes count]];

    for (PithosNode *node in draggedNodes) {

        [names addObject:node.displayName];

        // If the node is a subdir ask if the whole tree should be downloaded

        if ([node class] == [PithosSubdirNode class]) {

            NSAlert *alert = [[NSAlert alloc] init];

            [alert setMessageText:@"Download directory"];

            [alert setInformativeText:[NSString stringWithFormat:@"'%@' is a directory, do you want to download its contents?", node.displayName]];

            [alert addButtonWithTitle:@"OK"];

            [alert addButtonWithTitle:@"Cancel"];

            NSInteger choice = [alert runModal];

            if (choice == NSAlertFirstButtonReturn)

                [self downloadNode:node toDirectory:[dropDestination path] withNewFileName:nil version:nil checkIfExists:YES];

        } else {

            [self downloadNode:node toDirectory:[dropDestination path] withNewFileName:nil version:nil checkIfExists:YES];

        }

    }

    return names;

}

#pragma mark Drag and Drop destination

- (NSDragOperation)browser:aBrowser 

              validateDrop:(id<NSDraggingInfo>)info 

               proposedRow:(NSInteger *)row 

                    column:(NSInteger *)column 

             dropOperation:(NSBrowserDropOperation *)dropOperation {

    NSDragOperation result = NSDragOperationNone;

    if ([[[info draggingPasteboard] types] containsObject:NSFilenamesPboardType]) {

        // For a drop above, the drop is redirected to the parent item

        if (*dropOperation == NSBrowserDropAbove)

            *row = -1;

        // Only allow dropping in folders

        if (*column != -1) {

            PithosNode *dropNode;

            if (*row != -1) {

                // Check if the node is not a folder and if so redirect to the parent item

                dropNode = [browser itemAtRow:*row inColumn:*column];

                if ([dropNode class] == [PithosObjectNode class])

                    *row = -1;

            }

            if (*row == -1)

                dropNode = [browser parentForItemsInColumn:*column];

            if (!dropNode.shared && 

                (!dropNode.sharingAccount || 

                 ([dropNode class] == [PithosSubdirNode class]) || 

                 ([dropNode class] == [PithosContainerNode class]))) {

                *dropOperation = NSBrowserDropOn;

                result = NSDragOperationCopy;

            }

        }

    } else if ([[[info draggingPasteboard] types] containsObject:NSFilesPromisePboardType]) {

        // For a drop above, the drop is redirected to the parent item

        if (*dropOperation == NSBrowserDropAbove) 

            *row = -1;

        // Only allow dropping in folders

        if (*column != -1) {

            PithosNode *dropNode;

            if (*row != -1) {

                // Check if the node is not a folder and if so redirect to the parent item

                dropNode = [browser itemAtRow:*row inColumn:*column];

                if ([dropNode class] == [PithosObjectNode class])

                    *row = -1;

            }

            if (*row == -1)

                dropNode = [browser parentForItemsInColumn:*column];

            if (!dropNode.shared && !dropNode.sharingAccount) {

                if ([info draggingSourceOperationMask] & NSDragOperationMove) {

                    // NSDragOperationCopy | NSDragOperationMove -> NSDragOperationMove

                    if ((([dropNode class] == [PithosContainerNode class]) || 

                         dropNode.pithosObject.subdir || 

                         ![dropNode.pithosObject.name hasSuffix:@"/"]) && 

                        ![dropNode isEqualTo:draggedParentNode]) { 

    //                    ![dropNode isEqualTo:draggedParentNode] && 

    //                    ![draggedNodes containsObject:dropNode]) {                

                        result = NSDragOperationMove;

                    }

                } else if ([info draggingSourceOperationMask] & NSDragOperationCopy) {

                    // NSDragOperationCopy (Option modifier) -> NSDragOperationCopy

                    if (([dropNode class] == [PithosContainerNode class]) || 

                        dropNode.pithosObject.subdir || 

                        ![dropNode.pithosObject.name hasSuffix:@"/"]) { 

                        result = NSDragOperationCopy;

                    }

                }

            }

        }

    }

    return result;

}

- (BOOL)browser:(NSBrowser *)aBrowser 

     acceptDrop:(id<NSDraggingInfo>)info 

          atRow:(NSInteger)row 

         column:(NSInteger)column 

  dropOperation:(NSBrowserDropOperation)dropOperation {

    if ([[[info draggingPasteboard] types] containsObject:NSFilenamesPboardType]) {

        NSArray *filenames = [[info draggingPasteboard] propertyListForType:NSFilenamesPboardType];

        DLog(@"drag in operation: %lu filenames: %@", [info draggingSourceOperationMask], filenames);

        if ((column != -1) && (filenames != nil)) {

            PithosNode *node;

            if (row != -1)

                node = [browser itemAtRow:row inColumn:column];

            else

                node = [browser parentForItemsInColumn:column];

            DLog(@"drag in node: %@", node.url);

            return [self uploadFiles:filenames toNode:node];

        }

    } else if ([[[info draggingPasteboard] types] containsObject:NSFilesPromisePboardType]) {

        DLog(@"drag local operation: %lu nodes: %@", [info draggingSourceOperationMask], draggedNodes);

        if ((column != -1) && (draggedNodes != nil)) {

            PithosNode *node;

            if (row != -1)

                node = [browser itemAtRow:row inColumn:column];

            else

                node = [browser parentForItemsInColumn:column];

            DLog(@"drag local node: %@", node.url);

            if ([info draggingSourceOperationMask] & NSDragOperationMove)

                return [self moveNodes:draggedNodes toNode:node];

            else if ([info draggingSourceOperationMask] & NSDragOperationCopy)

                return [self cpyNodes:draggedNodes toNode:node];

        }

    }

    return NO;

}

#pragma mark -

#pragma mark NSBrowser Actions

- (void)browserDoubleAction:(id)sender {

    NSInteger column = [browser clickedColumn];

    NSInteger row = [browser clickedRow];

    if ((column == -1) || (row == -1))

        return;

    NSIndexPath *clickedNodeIndexPath = [[browser indexPathForColumn:column] indexPathByAddingIndex:row];

    NSArray *menuNodesIndexPaths = [browser selectionIndexPaths];

    NSMutableArray *menuNodes = [NSMutableArray arrayWithCapacity:[menuNodesIndexPaths count]];

    if ([menuNodesIndexPaths containsObject:clickedNodeIndexPath]) {

        for (NSIndexPath *nodeIndexPath in menuNodesIndexPaths) {

            [menuNodes addObject:[browser itemAtIndexPath:nodeIndexPath]];

        }

    } else {

        [menuNodes addObject:[browser itemAtIndexPath:clickedNodeIndexPath]];

    }

    NSMenuItem *menuItem = [[NSMenuItem alloc] init];

    menuItem.representedObject = menuNodes;

    [self menuDownload:menuItem];

}

#pragma mark -

#pragma mark Drag and Drop methods

- (void)downloadNode:(PithosNode *)node toDirectory:(NSString *)dirPath withNewFileName:(NSString *)newFileName 

             version:(NSString *)version checkIfExists:(BOOL)checkIfExists {

    if ([node class] == [PithosSubdirNode class]) {

        // XXX newFilename and version are ignored in the case of a subdir node for now

        // Operation: Download a subdir node and its descendants

        // The resulting ASIPithosObjectRequests are chained through dependencies

        __block NSOperation *operation = [NSBlockOperation blockOperationWithBlock:^{

            @autoreleasepool {

                if (operation.isCancelled)

                    return;

                NSArray *objectRequests = [PithosUtilities objectDataRequestsForSubdirWithPithos:pithosAccountManager.pithos

                                                                                   containerName:node.pithosContainer.name 

                                                                                      objectName:node.pithosObject.name 

                                                                                     toDirectory:dirPath 

                                                                                   checkIfExists:checkIfExists 

                                                                                  sharingAccount:node.sharingAccount];

                if (!operation.isCancelled && objectRequests) {

                    ASIPithosObjectRequest *previousObjectRequest = nil;

                    for (__block ASIPithosObjectRequest *objectRequest in objectRequests) {

                        if (operation.isCancelled)

                            return;

                        objectRequest.delegate = self;

                        objectRequest.didFinishSelector = @selector(performRequestFinishedDelegateInBackground:);

                        objectRequest.didFailSelector = @selector(performRequestFailedDelegateInBackground:);

                        NSString *messagePrefix = [NSString stringWithFormat:@"Downloading '%@'", [objectRequest.userInfo objectForKey:@"fileName"]];

                        PithosActivity *activity = [activityFacility startActivityWithType:PithosActivityDownload 

                                                                                   message:[messagePrefix stringByAppendingString:@" (0%)"]

                                                                                totalBytes:[[objectRequest.userInfo objectForKey:@"bytes"] unsignedIntegerValue] 

                                                                              currentBytes:0];

                        dispatch_async(dispatch_get_main_queue(), ^{

                            [activityFacility updateActivity:activity withMessage:activity.message];  

                        });

                        [(NSMutableDictionary *)objectRequest.userInfo addEntriesFromDictionary:

                         [NSDictionary dictionaryWithObjectsAndKeys:

                          activity, @"activity", 

                          [messagePrefix stringByAppendingString:@" (stopped)"], @"stoppedActivityMessage", 

                          [messagePrefix stringByAppendingString:@" (failed)"], @"failedActivityMessage", 

                          [messagePrefix stringByAppendingString:@" (100%)"], @"finishedActivityMessage", 

                          [NSNumber numberWithInteger:NSOperationQueuePriorityNormal], @"priority", 

                          [NSNumber numberWithUnsignedInteger:10], @"retries", 

                          NSStringFromSelector(@selector(downloadObjectFinished:)), @"didFinishSelector", 

                          NSStringFromSelector(@selector(requestFailed:)), @"didFailSelector", 

                          downloadNetworkQueue, @"networkQueue", 

                          @"download", @"operationType", 

                          nil]];

                        [objectRequest setBytesReceivedBlock:^(unsigned long long size, unsigned long long total){

                            [activityFacility updateActivity:activity 

                                                 withMessage:[messagePrefix stringByAppendingFormat:@" (%.0f%%)", (activity.totalBytes ? (100*(activity.currentBytes + size + 0.0)/(activity.totalBytes + 0.0)) : 100)] 

                                                  totalBytes:activity.totalBytes 

                                                currentBytes:(activity.currentBytes + size)];

                        }];

                        if (previousObjectRequest)

                            [objectRequest addDependency:previousObjectRequest];

                        previousObjectRequest = objectRequest;

                        [downloadNetworkQueue addOperation:[PithosUtilities prepareRequest:objectRequest]];

                    }

                }

            }

        }];

        [downloadQueue addOperation:operation];

    } else if ([node class] == [PithosObjectNode class]) {

        // Operation: Download an object node

        __block NSOperation *operation = [NSBlockOperation blockOperationWithBlock:^{

            @autoreleasepool {

                if (operation.isCancelled)

                    return;

                __block ASIPithosObjectRequest *objectRequest = [PithosUtilities objectDataRequestWithPithos:pithosAccountManager.pithos

                                                                                               containerName:node.pithosContainer.name 

                                                                                                  objectName:node.pithosObject.name 

                                                                                                     version:version 

                                                                                                toDirectory:dirPath 

                                                                                             withNewFileName:newFileName 

                                                                                               checkIfExists:checkIfExists 

                                                                                              sharingAccount:node.sharingAccount];

                if (!operation.isCancelled && objectRequest) {

                    objectRequest.delegate = self;

                    objectRequest.didFinishSelector = @selector(performRequestFinishedDelegateInBackground:);

                    objectRequest.didFailSelector = @selector(performRequestFailedDelegateInBackground:);

                    NSString *messagePrefix = [NSString stringWithFormat:@"Downloading '%@'", [objectRequest.userInfo objectForKey:@"fileName"]];

                    PithosActivity *activity = [activityFacility startActivityWithType:PithosActivityDownload 

                                                                               message:[messagePrefix stringByAppendingString:@" (0%)"]

                                                                            totalBytes:node.pithosObject.bytes 

                                                                          currentBytes:0];

                    dispatch_async(dispatch_get_main_queue(), ^{

                        [activityFacility updateActivity:activity withMessage:activity.message];  

                    });

                    [(NSMutableDictionary *)objectRequest.userInfo addEntriesFromDictionary:

                     [NSDictionary dictionaryWithObjectsAndKeys:

                      activity, @"activity", 

                      [messagePrefix stringByAppendingString:@" (stopped)"], @"stoppedActivityMessage", 

                      [messagePrefix stringByAppendingString:@" (failed)"], @"failedActivityMessage", 

                      [messagePrefix stringByAppendingString:@" (100%)"], @"finishedActivityMessage", 

                      [NSNumber numberWithInteger:NSOperationQueuePriorityNormal], @"priority", 

                      [NSNumber numberWithUnsignedInteger:10], @"retries", 

                      NSStringFromSelector(@selector(downloadObjectFinished:)), @"didFinishSelector", 

                      NSStringFromSelector(@selector(requestFailed:)), @"didFailSelector", 

                      downloadNetworkQueue, @"networkQueue", 

                      @"download", @"operationType", 

                      nil]];

                    [objectRequest setBytesReceivedBlock:^(unsigned long long size, unsigned long long total){

                        [activityFacility updateActivity:activity 

                                             withMessage:[messagePrefix stringByAppendingFormat:@" (%.0f%%)", (activity.totalBytes ? (100*(activity.currentBytes + size + 0.0)/(activity.totalBytes + 0.0)) : 100)] 

                                              totalBytes:activity.totalBytes 

                                            currentBytes:(activity.currentBytes + size)];

                    }];

                    [downloadNetworkQueue addOperation:[PithosUtilities prepareRequest:objectRequest]];

                }

            }

        }];

        [downloadQueue addOperation:operation];

    }

}

- (BOOL)uploadFiles:(NSArray *)filenames toNode:(PithosNode *)destinationNode {

    if (([destinationNode class] != [PithosSubdirNode class]) && ([destinationNode class] != [PithosContainerNode class]))

        return NO;

    NSFileManager *fileManager = [NSFileManager defaultManager];

    NSString *containerName = [NSString stringWithString:destinationNode.pithosContainer.name];

    NSString *objectNamePrefix;

    if ([destinationNode class] == [PithosSubdirNode class])

        objectNamePrefix = [NSString stringWithString:destinationNode.pithosObject.name];

    else

        objectNamePrefix = [NSString string];

    if ((destinationNode.pithosContainer.blockHash == nil) || (destinationNode.pithosContainer.blockSize == 0)) {

        ASIPithosContainerRequest *containerRequest = [ASIPithosContainerRequest containerMetadataRequestWithPithos:pithosAccountManager.pithos

                                                                                                      containerName:containerName];

        [PithosUtilities startAndWaitForRequest:containerRequest];

        if ([containerRequest error]) {

            [PithosUtilities httpRequestErrorAlertWithRequest:containerRequest];

            return NO;

        } else if (containerRequest.responseStatusCode != 204) {

            [PithosUtilities unexpectedResponseStatusAlertWithRequest:containerRequest];

            return NO;

        }

        destinationNode.pithosContainer.blockHash = [containerRequest blockHash];

        destinationNode.pithosContainer.blockSize = [containerRequest blockSize];

    }    

    NSUInteger blockSize = destinationNode.pithosContainer.blockSize;

    NSString *blockHash = destinationNode.pithosContainer.blockHash;

    for (NSString *filePath in filenames) {

        BOOL isDirectory;

        if ([fileManager fileExistsAtPath:filePath isDirectory:&isDirectory]) {

            if (!isDirectory) {

                // Upload file

                NSString *objectName = [[objectNamePrefix stringByAppendingPathComponent:[filePath lastPathComponent]] 

                                        precomposedStringWithCanonicalMapping];

                // Operation: Upload a local file

                __block NSOperation *operation = [NSBlockOperation blockOperationWithBlock:^{

                    @autoreleasepool {

                        if (operation.isCancelled)

                            return;

                        NSError *error = nil;

                        NSString *contentType = [PithosUtilities contentTypeOfFile:filePath error:&error];

                        if (contentType == nil)

                            contentType = @"application/octet-stream";

                        #if DEBUG_PITHOS

                        if (error)

                            DLog(@"contentType detection error: %@", error);

                        #endif

                        NSArray *hashes = nil;

                        if (operation.isCancelled)

                            return;

                        ASIPithosObjectRequest *objectRequest = [PithosUtilities writeObjectDataRequestWithPithos:pithosAccountManager.pithos

                                                                                                    containerName:containerName 

                                                                                                       objectName:objectName 

                                                                                                      contentType:contentType 

                                                                                                        blockSize:blockSize 

                                                                                                        blockHash:blockHash 

                                                                                                          forFile:filePath 

                                                                                                    checkIfExists:YES 

                                                                                                           hashes:&hashes 

                                                                                                   sharingAccount:destinationNode.sharingAccount];

                        if (!operation.isCancelled && objectRequest) {

                            objectRequest.delegate = self;

                            objectRequest.didFinishSelector = @selector(performRequestFinishedDelegateInBackground:);

                            objectRequest.didFailSelector = @selector(performRequestFailedDelegateInBackground:);

                            NSString *messagePrefix = [NSString stringWithFormat:@"Uploading '%@'", [objectRequest.userInfo objectForKey:@"fileName"]];

                            PithosActivity *activity = [activityFacility startActivityWithType:PithosActivityUpload 

                                                                                       message:[messagePrefix stringByAppendingString:@" (0%)"]

                                                                                    totalBytes:[[objectRequest.userInfo objectForKey:@"bytes"] unsignedIntegerValue]

                                                                                  currentBytes:0];

                            [(NSMutableDictionary *)objectRequest.userInfo addEntriesFromDictionary:

                             [NSDictionary dictionaryWithObjectsAndKeys:

                              containerName, @"containerName", 

                              objectName, @"objectName", 

                              contentType, @"contentType", 

                              [NSNumber numberWithUnsignedInteger:blockSize], @"blockSize", 

                              blockHash, @"blockHash", 

                              filePath, @"filePath", 

                              hashes, @"hashes", 

                              [NSArray arrayWithObject:destinationNode], @"refreshNodes", 

                              [NSNumber numberWithBool:YES], @"refresh", 

                              [NSNumber numberWithUnsignedInteger:10], @"iteration", 

                              activity, @"activity", 

                              [messagePrefix stringByAppendingString:@" (stopped)"], @"stoppedActivityMessage", 

                              [messagePrefix stringByAppendingString:@" (failed)"], @"failedActivityMessage", 

                              [messagePrefix stringByAppendingString:@" (100%)"], @"finishedActivityMessage", 

                              [NSNumber numberWithInteger:NSOperationQueuePriorityNormal], @"priority", 

                              [NSNumber numberWithUnsignedInteger:10], @"retries", 

                              NSStringFromSelector(@selector(uploadObjectUsingHashMapFinished:)), @"didFinishSelector", 

                              NSStringFromSelector(@selector(requestFailed:)), @"didFailSelector", 

                              uploadNetworkQueue, @"networkQueue", 

                              @"upload", @"operationType", 

                              nil]];

                            if (destinationNode.sharingAccount)

                                [(NSMutableDictionary *)objectRequest.userInfo setObject:destinationNode.sharingAccount forKey:@"sharingAccount"];

                            [uploadNetworkQueue addOperation:[PithosUtilities prepareRequest:objectRequest]];

                        }

                    }

                }];

                [uploadQueue addOperation:operation];

            } else {

                // Upload directory, confirm first

                NSAlert *alert = [[NSAlert alloc] init];

                [alert setMessageText:@"Upload directory"];

                [alert setInformativeText:[NSString stringWithFormat:@"'%@' is a directory, do you want to upload it and its contents?", filePath]];

                [alert addButtonWithTitle:@"OK"];

                [alert addButtonWithTitle:@"Cancel"];

                NSInteger choice = [alert runModal];

                if (choice == NSAlertFirstButtonReturn) {

                    NSString *objectName = [[objectNamePrefix stringByAppendingPathComponent:[filePath lastPathComponent]] 

                                            precomposedStringWithCanonicalMapping];

                    // Operation: Upload a local directory and its descendants

                    // The resulting ASIPithosObjectRequests are chained through dependencies

                    __block NSOperation *operation = [NSBlockOperation blockOperationWithBlock:^{

                        @autoreleasepool {

                            if (operation.isCancelled)

                                return;

                            NSMutableArray *objectNames = nil;

                            NSMutableArray *contentTypes = nil;

                            NSMutableArray *filePaths = nil;

                            NSMutableArray *hashesArrays = nil;

                            NSMutableArray *directoryObjectRequests = nil;

                            NSArray *objectRequests = [PithosUtilities writeObjectDataRequestsWithPithos:pithosAccountManager.pithos

                                                                                           containerName:containerName 

                                                                                              objectName:objectName 

                                                                                               blockSize:blockSize 

                                                                                               blockHash:blockHash 

                                                                                            forDirectory:filePath 

                                                                                           checkIfExists:YES 

                                                                                             objectNames:&objectNames

                                                                                            contentTypes:&contentTypes

                                                                                               filePaths:&filePaths

                                                                                            hashesArrays:&hashesArrays 

                                                                                 directoryObjectRequests:&directoryObjectRequests 

                                                                                          sharingAccount:destinationNode.sharingAccount];

                            if (operation.isCancelled)

                                return;

                            ASIPithosObjectRequest *previousObjectRequest = nil;

                            for (ASIPithosObjectRequest *objectRequest in directoryObjectRequests) {

                                if (operation.isCancelled)

                                    return;

                                objectRequest.delegate = self;

                                objectRequest.didFinishSelector = @selector(performRequestFinishedDelegateInBackground:);

                                objectRequest.didFailSelector = @selector(performRequestFailedDelegateInBackground:);

                                NSString *messagePrefix = [NSString stringWithFormat:@"Creating directory '%@'", [objectRequest.userInfo objectForKey:@"fileName"]];

                                PithosActivity *activity = [activityFacility startActivityWithType:PithosActivityCreateDirectory 

                                                                                           message:messagePrefix];

                                [(NSMutableDictionary *)objectRequest.userInfo addEntriesFromDictionary:

                                 [NSDictionary dictionaryWithObjectsAndKeys:

                                  [NSNumber numberWithBool:YES], @"refresh", 

                                  activity, @"activity", 

                                  [messagePrefix stringByAppendingString:@" (stopped)"], @"stoppedActivityMessage", 

                                  [messagePrefix stringByAppendingString:@" (failed)"], @"failedActivityMessage", 

                                  [messagePrefix stringByAppendingString:@" (finished)"], @"finishedActivityMessage", 

                                  [NSNumber numberWithInteger:NSOperationQueuePriorityNormal], @"priority", 

                                  [NSNumber numberWithUnsignedInteger:10], @"retries", 

                                  NSStringFromSelector(@selector(uploadDirectoryObjectFinished:)), @"didFinishSelector", 

                                  NSStringFromSelector(@selector(requestFailed:)), @"didFailSelector", 

                                  uploadNetworkQueue, @"networkQueue", 

                                  @"upload", @"operationType", 

                                  nil]];

                                if (previousObjectRequest)

                                    [objectRequest addDependency:previousObjectRequest];

                                previousObjectRequest = objectRequest;

                                [uploadNetworkQueue addOperation:[PithosUtilities prepareRequest:objectRequest]];

                            }

                            if (!operation.isCancelled && objectRequests) {

                                for (NSUInteger i = 0 ; i < [objectRequests count] ; i++) {

                                    if (operation.isCancelled)

                                        return;

                                    ASIPithosObjectRequest *objectRequest = [objectRequests objectAtIndex:i];

                                    objectRequest.delegate = self;

                                    objectRequest.didFinishSelector = @selector(performRequestFinishedDelegateInBackground:);

                                    objectRequest.didFailSelector = @selector(performRequestFailedDelegateInBackground:);

                                    NSString *messagePrefix = [NSString stringWithFormat:@"Uploading '%@'", [objectRequest.userInfo objectForKey:@"fileName"]];

                                    PithosActivity *activity = [activityFacility startActivityWithType:PithosActivityUpload 

                                                                                               message:[messagePrefix stringByAppendingString:@" (0%)"]

                                                                                            totalBytes:[[objectRequest.userInfo objectForKey:@"bytes"] unsignedIntegerValue]

                                                                                          currentBytes:0];

                                    [(NSMutableDictionary *)objectRequest.userInfo addEntriesFromDictionary:

                                     [NSDictionary dictionaryWithObjectsAndKeys:

                                      containerName, @"containerName", 

                                      [objectNames objectAtIndex:i], @"objectName", 

                                      [contentTypes objectAtIndex:i], @"contentType", 

                                      [NSNumber numberWithUnsignedInteger:blockSize], @"blockSize", 

                                      blockHash, @"blockHash", 

                                      [filePaths objectAtIndex:i], @"filePath", 

                                      [hashesArrays objectAtIndex:i], @"hashes", 

                                      [NSNumber numberWithBool:YES], @"refresh", 

                                      [NSNumber numberWithUnsignedInteger:10], @"iteration", 

                                      activity, @"activity", 

                                      [messagePrefix stringByAppendingString:@" (stopped)"], @"stoppedActivityMessage", 

                                      [messagePrefix stringByAppendingString:@" (failed)"], @"failedActivityMessage", 

                                      [messagePrefix stringByAppendingString:@" (100%)"], @"finishedActivityMessage", 

                                      [NSNumber numberWithInteger:NSOperationQueuePriorityNormal], @"priority", 

                                      [NSNumber numberWithUnsignedInteger:10], @"retries", 

                                      NSStringFromSelector(@selector(uploadObjectUsingHashMapFinished:)), @"didFinishSelector", 

                                      NSStringFromSelector(@selector(requestFailed:)), @"didFailSelector", 

                                      uploadNetworkQueue, @"networkQueue", 

                                      @"upload", @"operationType", 

                                      nil]];

                                    if (destinationNode.sharingAccount)

                                        [(NSMutableDictionary *)objectRequest.userInfo setObject:destinationNode.sharingAccount forKey:@"sharingAccount"];

                                    if (previousObjectRequest)

                                        [objectRequest addDependency:previousObjectRequest];

                                    previousObjectRequest = objectRequest;

                                    [uploadNetworkQueue addOperation:[PithosUtilities prepareRequest:objectRequest]];

                                }

                            }

                        }

                    }];

                    [uploadQueue addOperation:operation];

                }

            }

        }

    }

    return YES;

}

- (BOOL)moveNodes:(NSArray *)nodes toNode:(PithosNode *)destinationNode {

    if ((([destinationNode class] != [PithosSubdirNode class]) && ([destinationNode class] != [PithosContainerNode class])) ||

        (([destinationNode class] == [PithosSubdirNode class]) && !destinationNode.pithosObject.subdir && [destinationNode.pithosObject.name hasSuffix:@"/"])) 

        return NO;

    NSString *containerName = [NSString stringWithString:destinationNode.pithosContainer.name];

    NSString *objectNamePrefix;

    if ([destinationNode class] == [PithosSubdirNode class])

        objectNamePrefix = [NSString stringWithString:destinationNode.pithosObject.name];

    else

        objectNamePrefix = [NSString string];

    for (PithosNode *node in nodes) {

        if (([node class] == [PithosObjectNode class]) || 

            (([node class] == [PithosSubdirNode class]) && !node.pithosObject.subdir && [node.pithosObject.name hasSuffix:@"/"])) {

            // Operation: Move an object or subdir/ node

            __block NSOperation *operation = [NSBlockOperation blockOperationWithBlock:^{

                @autoreleasepool {

                    if (operation.isCancelled)

                        return;

                    NSString *destinationObjectName = [objectNamePrefix stringByAppendingPathComponent:node.displayName];

                    if ([node.pithosObject.name hasSuffix:@"/"])

                        destinationObjectName = [destinationObjectName stringByAppendingString:@"/"];

                    ASIPithosObjectRequest *objectRequest = [PithosUtilities moveObjectRequestWithPithos:pithosAccountManager.pithos

                                                                                           containerName:node.pithosContainer.name 

                                                                                              objectName:node.pithosObject.name 

                                                                                destinationContainerName:containerName 

                                                                                   destinationObjectName:destinationObjectName 

                                                                                           checkIfExists:YES];

                    if (!operation.isCancelled && objectRequest) {

                        objectRequest.delegate = self;

                        objectRequest.didFinishSelector = @selector(performRequestFinishedDelegateInBackground:);

                        objectRequest.didFailSelector = @selector(performRequestFailedDelegateInBackground:);

                        NSString *messagePrefix = [NSString stringWithFormat:@"Moving '%@/%@' to '%@/%@'", 

                                                   [objectRequest.userInfo objectForKey:@"sourceContainerName"], 

                                                   [objectRequest.userInfo objectForKey:@"sourceObjectName"], 

                                                   [objectRequest.userInfo objectForKey:@"destinationContainerName"], 

                                                   [objectRequest.userInfo objectForKey:@"destinationObjectName"]];

                        PithosActivity *activity = [activityFacility startActivityWithType:PithosActivityMove 

                                                                                   message:messagePrefix];

                        [(NSMutableDictionary *)(objectRequest.userInfo) addEntriesFromDictionary:

                         [NSDictionary dictionaryWithObjectsAndKeys:

                          [NSArray arrayWithObjects:node.parent, destinationNode, nil], @"forceRefreshNodes", 

                          activity, @"activity", 

                          [messagePrefix stringByAppendingString:@" (stopped)"], @"stoppedActivityMessage", 

                          [messagePrefix stringByAppendingString:@" (failed)"], @"failedActivityMessage", 

                          [messagePrefix stringByAppendingString:@" (finished)"], @"finishedActivityMessage", 

                          [NSNumber numberWithInteger:NSOperationQueuePriorityHigh], @"priority", 

                          [NSNumber numberWithUnsignedInteger:10], @"retries", 

                          NSStringFromSelector(@selector(moveFinished:)), @"didFinishSelector", 

                          NSStringFromSelector(@selector(requestFailed:)), @"didFailSelector", 

                          moveNetworkQueue, @"networkQueue", 

                          @"move", @"operationType", 

                          nil]];

                        [moveNetworkQueue addOperation:[PithosUtilities prepareRequest:objectRequest priority:NSOperationQueuePriorityHigh]];

                    }

                }

            }];

            [moveQueue addOperation:operation];

        } else if ([node class] == [PithosSubdirNode class]) {

            // Operation: Move a subdir node and its descendants

            // The resulting ASIPithosObjectRequests are chained through dependencies

            __block NSOperation *operation = [NSBlockOperation blockOperationWithBlock:^{

                @autoreleasepool {

                    if (operation.isCancelled)

                        return;

                    NSString *destinationObjectName = [objectNamePrefix stringByAppendingPathComponent:node.displayName];

                    if (node.pithosObject.subdir)

                        destinationObjectName = [destinationObjectName stringByAppendingString:@"/"];

                    NSArray *objectRequests = [PithosUtilities moveObjectRequestsForSubdirWithPithos:pithosAccountManager.pithos

                                                                                       containerName:node.pithosContainer.name 

                                                                                          objectName:node.pithosObject.name 

                                                                            destinationContainerName:containerName 

                                                                               destinationObjectName:destinationObjectName 

                                                                                       checkIfExists:YES];

                    if (!operation.isCancelled && objectRequests) {

                        ASIPithosObjectRequest *previousObjectRequest = nil;

                        for (ASIPithosObjectRequest *objectRequest in objectRequests) {

                            if (operation.isCancelled)

                                return;

                            objectRequest.delegate = self;

                            objectRequest.didFinishSelector = @selector(performRequestFinishedDelegateInBackground:);

                            objectRequest.didFailSelector = @selector(performRequestFailedDelegateInBackground:);

                            NSString *messagePrefix = [NSString stringWithFormat:@"Moving '%@/%@' to '%@/%@'", 

                                                       [objectRequest.userInfo objectForKey:@"sourceContainerName"], 

                                                       [objectRequest.userInfo objectForKey:@"sourceObjectName"], 

                                                       [objectRequest.userInfo objectForKey:@"destinationContainerName"], 

                                                       [objectRequest.userInfo objectForKey:@"destinationObjectName"]];

                            PithosActivity *activity = [activityFacility startActivityWithType:PithosActivityMove 

                                                                                       message:messagePrefix];

                            [(NSMutableDictionary *)(objectRequest.userInfo) addEntriesFromDictionary:

                             [NSDictionary dictionaryWithObjectsAndKeys:

                              [NSArray arrayWithObjects:node.parent, destinationNode, nil], @"forceRefreshNodes", 

                              [NSNumber numberWithBool:YES], @"refresh", 

                              activity, @"activity", 

                              [messagePrefix stringByAppendingString:@" (stopped)"], @"stoppedActivityMessage", 

                              [messagePrefix stringByAppendingString:@" (failed)"], @"failedActivityMessage", 

                              [messagePrefix stringByAppendingString:@" (finished)"], @"finishedActivityMessage", 

                              [NSNumber numberWithInteger:NSOperationQueuePriorityHigh], @"priority", 

                              [NSNumber numberWithUnsignedInteger:10], @"retries", 

                              NSStringFromSelector(@selector(moveFinished:)), @"didFinishSelector", 

                              NSStringFromSelector(@selector(requestFailed:)), @"didFailSelector", 

                              moveNetworkQueue, @"networkQueue", 

                              @"move", @"operationType", 

                              nil]];

                            if (previousObjectRequest)

                                [objectRequest addDependency:previousObjectRequest];

                            previousObjectRequest = objectRequest;

                            [moveNetworkQueue addOperation:[PithosUtilities prepareRequest:objectRequest priority:NSOperationQueuePriorityHigh]];

                        }

                    }

                }

            }];

            [moveQueue addOperation:operation];

        }

    }

    return YES;

}

- (BOOL)cpyNodes:(NSArray *)nodes toNode:(PithosNode *)destinationNode {    

    if ((([destinationNode class] != [PithosSubdirNode class]) && ([destinationNode class] != [PithosContainerNode class])) ||

        (([destinationNode class] == [PithosSubdirNode class]) && !destinationNode.pithosObject.subdir && [destinationNode.pithosObject.name hasSuffix:@"/"])) 

        return NO;

    NSString *containerName = [NSString stringWithString:destinationNode.pithosContainer.name];

    NSString *objectNamePrefix;

    if ([destinationNode class] == [PithosSubdirNode class])

        objectNamePrefix = [NSString stringWithString:destinationNode.pithosObject.name];

    else

        objectNamePrefix = [NSString string];

    for (PithosNode *node in nodes) {

        if (([node class] == [PithosObjectNode class]) || 

            (([node class] == [PithosSubdirNode class]) && !node.pithosObject.subdir && [node.pithosObject.name hasSuffix:@"/"])) {

            // Operation: Copy an object or subdir/ node

            __block NSOperation *operation = [NSBlockOperation blockOperationWithBlock:^{

                @autoreleasepool {

                    if (operation.isCancelled)

                        return;

                    NSString *destinationObjectName;

                    if (![destinationNode isEqualTo:node.parent]) {

                        destinationObjectName = [objectNamePrefix stringByAppendingPathComponent:node.displayName];

                        if ([node.pithosObject.name hasSuffix:@"/"])

                            destinationObjectName = [destinationObjectName stringByAppendingString:@"/"];

                    } else {

                        destinationObjectName = [PithosUtilities safeObjectNameForPithos:pithosAccountManager.pithos

                                                                           containerName:containerName 

                                                                              objectName:node.pithosObject.name];

                    }

                    if (operation.isCancelled)

                        return;

                    ASIPithosObjectRequest *objectRequest = [PithosUtilities cpyObjectRequestWithPithos:pithosAccountManager.pithos

                                                                                           containerName:node.pithosContainer.name 

                                                                                              objectName:node.pithosObject.name 

                                                                                destinationContainerName:containerName 

                                                                                   destinationObjectName:destinationObjectName 

                                                                                           checkIfExists:YES 

                                                                                          sharingAccount:node.sharingAccount];

                    if (!operation.isCancelled && objectRequest) {

                        objectRequest.delegate = self;

                        objectRequest.didFinishSelector = @selector(performRequestFinishedDelegateInBackground:);

                        objectRequest.didFailSelector = @selector(performRequestFailedDelegateInBackground:);

                        NSString *messagePrefix = [NSString stringWithFormat:@"Copying '%@/%@' to '%@/%@'", 

                                                   [objectRequest.userInfo objectForKey:@"sourceContainerName"], 

                                                   [objectRequest.userInfo objectForKey:@"sourceObjectName"], 

                                                   [objectRequest.userInfo objectForKey:@"destinationContainerName"], 

                                                   [objectRequest.userInfo objectForKey:@"destinationObjectName"]];

                        PithosActivity *activity = [activityFacility startActivityWithType:PithosActivityCopy 

                                                                                   message:messagePrefix];

                        [(NSMutableDictionary *)(objectRequest.userInfo) addEntriesFromDictionary:

                         [NSDictionary dictionaryWithObjectsAndKeys:

                          [NSArray arrayWithObject:destinationNode], @"forceRefreshNodes", 

                          activity, @"activity", 

                          [messagePrefix stringByAppendingString:@" (stopped)"], @"stoppedActivityMessage", 

                          [messagePrefix stringByAppendingString:@" (failed)"], @"failedActivityMessage", 

                          [messagePrefix stringByAppendingString:@" (finished)"], @"finishedActivityMessage", 

                          [NSNumber numberWithInteger:NSOperationQueuePriorityHigh], @"priority", 

                          [NSNumber numberWithUnsignedInteger:10], @"retries", 

                          NSStringFromSelector(@selector(copyFinished:)), @"didFinishSelector", 

                          NSStringFromSelector(@selector(requestFailed:)), @"didFailSelector", 

                          copyNetworkQueue, @"networkQueue", 

                          @"copy", @"operationType", 

                          nil]];

                        [copyNetworkQueue addOperation:[PithosUtilities prepareRequest:objectRequest priority:NSOperationQueuePriorityHigh]];

                    }

                }

            }];

            [copyQueue addOperation:operation];

        } else if ([node class] == [PithosSubdirNode class]) {

            // Operation: Copy a subdir node and its descendants

            // The resulting ASIPithosObjectRequests are chained through dependencies

            __block NSOperation *operation = [NSBlockOperation blockOperationWithBlock:^{

                @autoreleasepool {

                    if (operation.isCancelled)

                        return;

                    NSString *destinationObjectName;

                    if (![destinationNode isEqualTo:node.parent]) {

                        destinationObjectName = [objectNamePrefix stringByAppendingPathComponent:node.displayName];

                        if (node.pithosObject.subdir)

                            destinationObjectName = [destinationObjectName stringByAppendingString:@"/"];

                    } else {

                        destinationObjectName = [PithosUtilities safeSubdirNameForPithos:pithosAccountManager.pithos 

                                                                           containerName:containerName 

                                                                              subdirName:node.pithosObject.name];

                    }

                    if (operation.isCancelled)

                        return;

                    NSArray *objectRequests = [PithosUtilities cpyObjectRequestsForSubdirWithPithos:pithosAccountManager.pithos

                                                                                       containerName:node.pithosContainer.name 

                                                                                          objectName:node.pithosObject.name 

                                                                            destinationContainerName:containerName 

                                                                               destinationObjectName:destinationObjectName 

                                                                                       checkIfExists:YES 

                                                                                      sharingAccount:node.sharingAccount];

                    if (!operation.isCancelled && objectRequests) {

                        ASIPithosObjectRequest *previousObjectRequest = nil;

                        for (ASIPithosObjectRequest *objectRequest in objectRequests) {

                            if (operation.isCancelled)

                                return;

                            objectRequest.delegate = self;

                            objectRequest.didFinishSelector = @selector(performRequestFinishedDelegateInBackground:);

                            objectRequest.didFailSelector = @selector(performRequestFailedDelegateInBackground:);

                            NSString *messagePrefix = [NSString stringWithFormat:@"Copying '%@/%@' to '%@/%@'", 

                                                       [objectRequest.userInfo objectForKey:@"sourceContainerName"], 

                                                       [objectRequest.userInfo objectForKey:@"sourceObjectName"], 

                                                       [objectRequest.userInfo objectForKey:@"destinationContainerName"], 

                                                       [objectRequest.userInfo objectForKey:@"destinationObjectName"]];

                            PithosActivity *activity = [activityFacility startActivityWithType:PithosActivityCopy 

                                                                                       message:messagePrefix];

                            [(NSMutableDictionary *)(objectRequest.userInfo) addEntriesFromDictionary:

                             [NSDictionary dictionaryWithObjectsAndKeys:

                              [NSArray arrayWithObject:destinationNode], @"forceRefreshNodes", 

                              activity, @"activity", 

                              [messagePrefix stringByAppendingString:@" (stopped)"], @"stoppedActivityMessage", 

                              [messagePrefix stringByAppendingString:@" (failed)"], @"failedActivityMessage", 

                              [messagePrefix stringByAppendingString:@" (finished)"], @"finishedActivityMessage", 

                              [NSNumber numberWithInteger:NSOperationQueuePriorityHigh], @"priority", 

                              [NSNumber numberWithUnsignedInteger:10], @"retries", 

                              NSStringFromSelector(@selector(copyFinished:)), @"didFinishSelector", 

                              NSStringFromSelector(@selector(requestFailed:)), @"didFailSelector", 

                              copyNetworkQueue, @"networkQueue", 

                              @"copy", @"operationType", 

                              nil]];

                            if (previousObjectRequest)

                                [objectRequest addDependency:previousObjectRequest];

                            previousObjectRequest = objectRequest;

                            [copyNetworkQueue addOperation:[PithosUtilities prepareRequest:objectRequest priority:NSOperationQueuePriorityHigh]];

                        }

                    }

                }

            }];

            [copyQueue addOperation:operation];

        }

    }

    return YES;

}

#pragma mark -

#pragma mark ASIHTTPRequestDelegate

- (void)performRequestFinishedDelegateInBackground:(ASIPithosRequest *)request {

    NSOperationQueue *callbackQueue;

    NSString *operationType = [request.userInfo objectForKey:@"operationType"];

    if ([operationType isEqualToString:@"move"])

        callbackQueue = moveCallbackQueue;

    else if ([operationType isEqualToString:@"copy"])

        callbackQueue = copyCallbackQueue;

    else if ([operationType isEqualToString:@"delete"])

        callbackQueue = deleteCallbackQueue;

    else if ([operationType isEqualToString:@"upload"])

        callbackQueue = uploadCallbackQueue;

    else if ([operationType isEqualToString:@"download"])

        callbackQueue = downloadCallbackQueue;

    else {

        dispatch_async(dispatch_get_main_queue(), ^{

            [activityFacility endActivity:[request.userInfo objectForKey:@"activity"] 

                              withMessage:[request.userInfo objectForKey:@"stoppedActivityMessage"]];

        });

        return;

    }

    // Add an operation to the callbackQueue with a completionBlock for the case of cancellation

    NSInvocationOperation *operation = [[NSInvocationOperation alloc] initWithTarget:self 

                                                                             selector:NSSelectorFromString([request.userInfo objectForKey:@"didFinishSelector"]) 

                                                                               object:request];

    operation.completionBlock = ^{

        @autoreleasepool {

            if ([[request.userInfo objectForKey:@"operation"] isCancelled]) {

                dispatch_async(dispatch_get_main_queue(), ^{

                    [activityFacility endActivity:[request.userInfo objectForKey:@"activity"] 

                                      withMessage:[request.userInfo objectForKey:@"stoppedActivityMessage"]];

                });

            }

        }

    };

    [(NSMutableDictionary *)request.userInfo setObject:operation forKey:@"operation"];

    [callbackQueue addOperation:operation];

}

- (void)performRequestFailedDelegateInBackground:(ASIPithosRequest *)request {

    if (request.isCancelled) {

        // Request has been cancelled 

        // The callbackQueue might be suspended so we call directly the callback method, since it does minimal work anyway

        [self performSelector:NSSelectorFromString([request.userInfo objectForKey:@"didFailSelector"]) 

                   withObject:request];

    } else {

        NSOperationQueue *callbackQueue;