Synnefo » Pithos MacOS Client

//  PithosAccount.h

//  pithos-macos

//

//

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

// without modification, are permitted provided that the following

//  PithosAccount.m

//  pithos-macos

//

//

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

// without modification, are permitted provided that the following

}

- (NSString *)stringByRemovingTrailingSlashes {

}

@end

- (PithosAccountNode *)accountNode {

    if (!accountNode) {

        accountNode.childrenUpdatedNotificationName = nil;

        accountNode.inheritChildrenUpdatedNotificationName = YES;

    }

- (PithosSharingAccountsNode *)sharingAccountsNode {

    if (!sharingAccountsNode) {

        sharingAccountsNode.childrenUpdatedNotificationName = nil;

        sharingAccountsNode.inheritChildrenUpdatedNotificationName = YES;

    }

                         manual:(BOOL)aManual

                      authToken:(NSString *)anAuthToken

                      authUser:(NSString *)anAuthUser

    self.authURLString = anAuthURLString;

    self.pithosObjectStoreURLString = aPithosObjectStoreURLString;

    self.astakosAccountURLString = anAstakosAccountURLString;

        [self updateUserCatalogForDisplaynames:nil UUIDs:[NSArray arrayWithObject:authUser]];

        self.active = YES;

            }

        }

    }

}

               syncDirectoryPath:(NSString *)aSyncDirectoryPath 

          syncAccountsDictionary:(NSMutableDictionary *)aSyncAccountsDictionary 

                  syncSkipHidden:(BOOL)aSyncSkipHidden {

- (void)updateServicesFromServiceCatalogRequest:(ASIPithosRequest *)serviceCatalogRequest {

    if (serviceCatalogRequest.responseStatusCode == 200) {

        NSMutableDictionary *services = [self servicesFromServiceCatalogRequest:serviceCatalogRequest];

        if (authToken.length) {

            NSDictionary *token = [serviceCatalogRequest token];

        }

    } else if (serviceCatalogRequest.responseStatusCode == 404) {

    }

}

        self.astakosWebloginURLString = [decoder decodeObjectForKey:@"astakosWebloginURLString"];

        self.manual = [decoder decodeBoolForKey:@"manual"];

        // Support for older versions.

        if (!authURLString && !pithosObjectStoreURLString && !astakosAccountURLString && !astakosWebloginURLString) {

            NSString *tmpURLString = [decoder decodeObjectForKey:@"serverURL"];

    [encoder encodeObject:authToken forKey:@"authToken"];

    [encoder encodeObject:authUser forKey:@"authUser"];

    [encoder encodeObject:userCatalog forKey:@"userCatalog"];

}

@end

//  PithosAccountNode.h

//  pithos-macos

//

//

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

// without modification, are permitted provided that the following

// or implied, of GRNET S.A.

#import "PithosNode.h"

@class ASIPithosAccountRequest;

@class ASIPithosAccount;

@interface PithosAccountNode : PithosNode {

    ASIPithosAccount *pithosAccount;

    ASIPithosAccountRequest *accountRequest;

    ASIPithosAccountRequest *applyMetadataAccountRequest;

    ASIPithosAccountRequest *refreshMetadataAccountRequest;

    NSMutableDictionary *translatedGroups;

}

@property(nonatomic, strong) ASIPithosAccount *pithosAccount;

@property(nonatomic, strong) ASIPithosAccountRequest *accountRequest;

@property(nonatomic, strong) ASIPithosAccountRequest *applyMetadataAccountRequest;

@property(nonatomic, strong) ASIPithosAccountRequest *refreshMetadataAccountRequest;

@property(nonatomic, strong) NSMutableDictionary *translatedGroups;

- (void)applyInfo;

- (void)refreshInfo;

@end

//  PithosAccountNode.m

//  pithos-macos

//

//

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

// without modification, are permitted provided that the following

static NSImage *sharedIcon = nil;

@implementation PithosAccountNode

+ (void)initialize {

	if (self == [PithosAccountNode class])

#pragma mark -

#pragma mark Object Lifecycle

- (void)dealloc {

    [accountRequest clearDelegatesAndCancel];

    [refreshMetadataAccountRequest clearDelegatesAndCancel];

}

#pragma mark -

}

- (void)setPithosAccount:(ASIPithosAccount *)aPithosAccount {

    if (![pithosAccount isEqualTo:aPithosAccount]) {

        pithosAccount = aPithosAccount;

}

- (NSString *)url {

}

- (NSArray *)children {

    @synchronized(self) {

        switch (freshness) {

            case PithosNodeStateFresh:

                break;

            case PithosNodeStateRefreshNeeded:

                freshness = PithosNodeStateRefreshing;

                                                                                         limit:0

                                                                                        marker:nil

                                                                                        shared:shared

                                                                                         until:nil];

                if (sharingAccount)

                else if (!forcedRefresh)

                    accountRequest.downloadCache = [ASIDownloadCache sharedCache];

                accountRequest.delegate = self;

                    NSMutableIndexSet *keptNodes = [NSMutableIndexSet indexSet];

                    for (ASIPithosContainer *container in containers) {

                        PithosContainerNode *node = [[PithosContainerNode alloc] initWithPithosAccountManager:pithosAccountManager

                                                                                              pithosContainer:container];

                        node.parent = self;

                        node.shared = shared;

                [self postChildrenUpdatedNotificationName];

            } else {

                // Do an additional request to fetch more objects

                                                                                         limit:0

                                                                                        marker:[[someContainers lastObject] name]

                                                                                        shared:shared

                                                                                         until:nil];

                if (sharingAccount)

                else if (!forcedRefresh)

                    accountRequest.downloadCache = [ASIDownloadCache sharedCache];

                accountRequest.delegate = self;

                [groups setObject:[NSArray arrayWithObject:@""] forKey:@"group"];

            }

                                                                                                        groups:groups

                                                                                                      metadata:pithosAccount.metadata

                                                                                                        update:NO];

- (void)refreshInfo {

    @synchronized(self) {

        if (refreshMetadataAccountRequest == nil) {

            refreshMetadataAccountRequest.delegate = self;

            refreshMetadataAccountRequest.didFinishSelector = @selector(performRequestFinishedDelegateInBackground:);

            refreshMetadataAccountRequest.didFailSelector = @selector(performRequestFailedDelegateInBackground:);

//  PithosBrowserController.h

//  pithos-macos

//

//

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

// without modification, are permitted provided that the following

#import <Cocoa/Cocoa.h>

#import "PithosActivityFacility.h"

@class PithosAccount;

@class PithosNode;

@class PithosAccountNode;

    BOOL browserInitialized;

    BOOL browserActive;

    PithosNode *rootNode;

    PithosAccountNode *accountNode;

    PithosEmptyNode *containersNode;

    NSOperationQueue *downloadCallbackQueue;

}

@property (nonatomic, strong) PithosAccountNode *accountNode;

@property (nonatomic, strong) NSArray *draggedNodes;

//  PithosBrowserController.m

//  pithos-macos

//

//

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

// without modification, are permitted provided that the following

#import "ASIPithosContainer.h"

#import "ASIPithosObject.h"

#import "PithosUtilities.h"

#import "UsingSizeTransformer.h"

#define REFRESH_TIMER_INTERVAL 5

@end

@implementation PithosBrowserController

@synthesize pithosAccountManager, accountNode;

@synthesize draggedNodes, draggedParentNode;

@synthesize clipboardNodes, clipboardParentNode, clipboardCopy;

    [activityProgressIndicator setMaxValue:1.0];

    activityFacility = [PithosActivityFacility defaultPithosActivityFacility];

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

    containersNodeChildren = [[NSMutableArray alloc] init];

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

    mySharedNode.displayName = @"shared by me";

    mySharedNode.shared = YES;

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

    othersSharedNode.displayName = @"shared with me";

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

    [uploadCallbackQueue setSuspended:NO];

    [downloadCallbackQueue setSuspended:NO];

    accountNode.pithosAccountManager = pithosAccountManager;

    mySharedNode.pithosAccountManager = pithosAccountManager;

    othersSharedNode.pithosAccountManager = pithosAccountManager;

//    [activityFacility reset];

    activityFacility.delegate = self;

    [self resetBrowser];

}

    }

}

#pragma mark -

#pragma mark Observers

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

    if (![NSThread isMainThread]) {

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

        return;

    }

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

        return;

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

    NSInteger lastColumn = [browser lastColumn];

    BOOL refreshAccountNode = NO;

    if (!containerPithosFound) {

        // Create pithos node

                                                                                                            containerName:@"pithos"];

        [PithosUtilities startAndWaitForRequest:containerRequest];

        if ([containerRequest error]) {

    }

    if (!containerTrashFound) {

        // Create trash node

                                                                                                            containerName:@"trash"];

        [PithosUtilities startAndWaitForRequest:containerRequest];

        if ([containerRequest error]) {

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

                NSError *error = nil;

                BOOL isDirectory;

                                            containerName:node.pithosContainer.name 

                                               objectName:destinationObjectName 

                                                    error:&error 

                }

                if (operation.isCancelled)

                    return;

                                                                                       containerName:node.pithosContainer.name 

                                                                                          objectName:node.pithosObject.name 

                                                                            destinationContainerName:node.pithosContainer.name 

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

                NSError *error = nil;

                BOOL isDirectory;

                                            containerName:node.pithosContainer.name 

                                               objectName:destinationObjectName 

                                                    error:&error 

                    return;

                if (node.pithosObject.subdir)

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

                                                                                   containerName:node.pithosContainer.name 

                                                                                      objectName:node.pithosObject.name 

                                                                        destinationContainerName:node.pithosContainer.name 

            @autoreleasepool {

                if (operation.isCancelled)

                    return;

                                                                                   containerName:node.pithosContainer.name 

                                                                                      objectName:node.pithosObject.name 

                                                                                     toDirectory:dirPath 

            @autoreleasepool {

                if (operation.isCancelled)

                    return;

                                                                                               containerName:node.pithosContainer.name 

                                                                                                  objectName:node.pithosObject.name 

                                                                                                     version:version 

    else

        objectNamePrefix = [NSString string];

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

                                                                                                      containerName:containerName];

        [PithosUtilities startAndWaitForRequest:containerRequest];

        if ([containerRequest error]) {

                        NSArray *hashes = nil;

                        if (operation.isCancelled)

                            return;

                                                                                                    containerName:containerName 

                                                                                                       objectName:objectName 

                                                                                                      contentType:contentType 

                            NSMutableArray *filePaths = nil;

                            NSMutableArray *hashesArrays = nil;

                            NSMutableArray *directoryObjectRequests = nil;

                                                                                           containerName:containerName 

                                                                                              objectName:objectName 

                                                                                               blockSize:blockSize 

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

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

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

                                                                                           containerName:node.pithosContainer.name 

                                                                                              objectName:node.pithosObject.name 

                                                                                destinationContainerName:containerName 

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

                    if (node.pithosObject.subdir)

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

                                                                                       containerName:node.pithosContainer.name 

                                                                                          objectName:node.pithosObject.name 

                                                                            destinationContainerName:containerName 

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

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

                    } else {

                                                                           containerName:containerName 

                                                                              objectName:node.pithosObject.name];

                    }

                    if (operation.isCancelled)

                        return;

                                                                                           containerName:node.pithosContainer.name 

                                                                                              objectName:node.pithosObject.name 

                                                                                destinationContainerName:containerName 

                        if (node.pithosObject.subdir)

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

                    } else {

                                                                           containerName:containerName 

                                                                              subdirName:node.pithosObject.name];

                    }

                    if (operation.isCancelled)

                        return;

                                                                                       containerName:node.pithosContainer.name 

                                                                                          objectName:node.pithosObject.name 

                                                                            destinationContainerName:containerName 

                                    currentBytes:currentBytes];

            });

            NSUInteger missingBlockIndex = [missingBlocks firstIndex];

                                                                                                             containerName:[objectRequest.userInfo objectForKey:@"containerName"] 

                                                                                                                 blockSize:blockSize 

                                                                                                                   forFile:[objectRequest.userInfo objectForKey:@"filePath"] 

            missingBlockIndex = [missingBlocks indexGreaterThanIndex:missingBlockIndex];

            if (missingBlockIndex == NSNotFound) {

                NSArray *hashes = [containerRequest.userInfo objectForKey:@"hashes"];

                                                                                               containerName:[containerRequest.userInfo objectForKey:@"containerName"] 

                                                                                                  objectName:[containerRequest.userInfo objectForKey:@"objectName"] 

                                                                                                 contentType:[containerRequest.userInfo objectForKey:@"contentType"] 

                [(NSMutableDictionary *)(newObjectRequest.userInfo) setObject:NSStringFromSelector(@selector(uploadObjectUsingHashMapFinished:)) forKey:@"didFinishSelector"];

                [uploadNetworkQueue addOperation:[PithosUtilities prepareRequest:newObjectRequest priority:[[newObjectRequest.userInfo objectForKey:@"priority"] integerValue]]];

            } else {

                                                                                                                 containerName:[containerRequest.userInfo objectForKey:@"containerName"]

                                                                                                                     blockSize:[[containerRequest.userInfo objectForKey:@"blockSize"] unsignedIntegerValue]

                                                                                                                       forFile:[containerRequest.userInfo objectForKey:@"filePath"] 

            @autoreleasepool {

                if (operation.isCancelled)

                    return;

                                                                      containerName:node.pithosContainer.name 

                                                                         subdirName:@"untitled folder"];

                NSString *fileName = [safeObjectName lastPathComponent];

                if (operation.isCancelled)

                    return;

                                                                                                   containerName:node.pithosContainer.name 

                                                                                                      objectName:safeObjectName 

                                                                                                            eTag:nil 

            @autoreleasepool {

                if (operation.isCancelled)

                    return;

                                                                      containerName:node.pithosContainer.name 

                                                                         subdirName:[node.pithosObject.name stringByAppendingPathComponent:@"untitled folder"]];

                NSString *fileName = [safeObjectName lastPathComponent];

                if (operation.isCancelled)

                    return;

                                                                                                   containerName:node.pithosContainer.name 

                                                                                                      objectName:safeObjectName 

                                                                                                            eTag:nil

                    NSString *fileName = [node.pithosObject.name lastPathComponent];

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

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

                                                                                                    containerName:node.pithosContainer.name 

                                                                                                       objectName:node.pithosObject.name];

                    if (operation.isCancelled)

                @autoreleasepool {

                    if (operation.isCancelled)

                        return;

                                                                                         containerName:node.pithosContainer.name 

                                                                                            objectName:node.pithosObject.name];

                    if (!operation.isCancelled && objectRequests) {

                @autoreleasepool {

                    if (operation.isCancelled)

                        return;

                                                                          containerName:@"trash" 

                                                                             objectName:node.pithosObject.name];

                    if (!operation.isCancelled && safeObjectName) {

                                                                                               containerName:node.pithosContainer.name 

                                                                                                  objectName:node.pithosObject.name 

                                                                                    destinationContainerName:@"trash" 

                @autoreleasepool {

                    if (operation.isCancelled)

                        return;

                                                                          containerName:@"trash" 

                                                                             subdirName:node.pithosObject.name];

                    if (!operation.isCancelled && safeObjectName) {

                                                                                           containerName:node.pithosContainer.name 

                                                                                              objectName:node.pithosObject.name 

                                                                                destinationContainerName:@"trash" 

//  PithosContainerNode.h

//  pithos-macos

//

//

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

// without modification, are permitted provided that the following

// or implied, of GRNET S.A.

#import "PithosNode.h"

@class ASIPithosContainer;

@class ASIPithosContainerRequest;

@interface PithosContainerNode : PithosNode {

    ASIPithosContainer *pithosContainer;

    ASIPithosContainerRequest *containerRequest;

    NSNumber *policyQuota;

}

@property(nonatomic, strong) ASIPithosContainer *pithosContainer;

@property(nonatomic, strong) ASIPithosContainerRequest *containerRequest;

@property(nonatomic, strong) NSString *prefix;

//  PithosContainerNode.m

//  pithos-macos

//

//

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

// without modification, are permitted provided that the following

#import "ASIPithosObject.h"

#import "ASIDownloadCache.h"

#import "PithosUtilities.h"

#import "PithosContainerNodeInfoController.h"

#import "PithosActivityFacility.h"

static NSImage *sharedIcon = nil;

@implementation PithosContainerNode

@synthesize policyVersioning, policyQuota;

+ (void)initialize {

#pragma mark -

#pragma mark Object Lifecycle

    if ((self = [super initWithPithosAccountManager:aPithosAccountManager])) {

        self.pithosContainer = aPithosContainer;

        self.icon = anIcon;

    }

    return self;

}

}

    ASIPithosContainer *container = [ASIPithosContainer container];

    container.name = aContainerName;

}

}

- (void)dealloc {

#pragma mark -

#pragma mark Properties

- (NSString *)url {

}

- (NSArray *)children {

                break;

            case PithosNodeStateRefreshNeeded:

                freshness = PithosNodeStateRefreshing;

                                                                                  containerName:pithosContainer.name

                                                                                          limit:0

                                                                                         marker:nil

                                                                                         shared:shared

                                                                                          until:nil];

                if (sharingAccount)

                else if (!forcedRefresh)

                    containerRequest.downloadCache = [ASIDownloadCache sharedCache];

                containerRequest.delegate = self;

                                if ((sameNameObjectIndex == NSNotFound) || 

                                    ![PithosUtilities isContentTypeDirectory:[[objects objectAtIndex:sameNameObjectIndex] contentType]]) {

                                    PithosSubdirNode *node = [[PithosSubdirNode alloc] initWithPithosAccountManager:pithosAccountManager

                                                                                                    pithosContainer:pithosContainer

                                                                                                       pithosObject:object];

                                    node.parent = self;

                                }

                            } else if ([PithosUtilities isContentTypeDirectory:object.contentType]) {

                                PithosSubdirNode *node = [[PithosSubdirNode alloc] initWithPithosAccountManager:pithosAccountManager

                                                                                                pithosContainer:pithosContainer

                                                                                                   pithosObject:object];

                                node.parent = self;

                                [newChildren addObject:node];

                            } else {

                                PithosObjectNode *node = [[PithosObjectNode alloc] initWithPithosAccountManager:pithosAccountManager

                                                                                                pithosContainer:pithosContainer

                                                                                                   pithosObject:object];

                                node.parent = self;

                [self postChildrenUpdatedNotificationName];

            } else {

                // Do an additional request to fetch more objects

                                                                                  containerName:pithosContainer.name

                                                                                          limit:0

                                                                                         marker:[[someObjects lastObject] name]

                                                                                         shared:shared

                                                                                          until:nil];

                if (sharingAccount)

                else if (!forcedRefresh)

                    containerRequest.downloadCache = [ASIDownloadCache sharedCache];

                containerRequest.delegate = self;

    @synchronized(self) {

        if (applyMetadataContainerRequest == nil) {

            [[pithosNodeInfoController window] makeFirstResponder:nil];

                                                                                                       containerName:pithosContainer.name

                                                                                                              policy:[NSDictionary dictionaryWithObjectsAndKeys:

                                                                                                                      policyVersioning, @"versioning",

- (void)refreshInfo {

    @synchronized(self) {

        if (refreshMetadataContainerRequest == nil) {

                                                                                                   containerName:pithosContainer.name];

            refreshMetadataContainerRequest.delegate = self;

            refreshMetadataContainerRequest.didFinishSelector = @selector(performRequestFinishedDelegateInBackground:);

//  PithosNode.m

//  pithos-macos

//

//

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

// without modification, are permitted provided that the following

}

#pragma mark -

#pragma mark Actions

- (void)invalidateChildren {

//  PithosObjectNode.h

//  pithos-macos

//

//

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

// without modification, are permitted provided that the following

// or implied, of GRNET S.A.

#import "PithosNode.h"

@class ASIPithosContainer;

@class ASIPithosObject;

@class ASIPithosObjectRequest;

@interface PithosObjectNode : PithosNode {

    ASIPithosContainer *pithosContainer;

    ASIPithosObject *pithosObject;

    NSArray *versions;

}

- (id)initWithPithosAccountManager:(PithosAccount *)aPithosAccountManager

                   pithosContainer:(ASIPithosContainer *)aPithosContainer

                      pithosObject:(ASIPithosObject *)aPithosObject;

@property (nonatomic, strong) ASIPithosContainer *pithosContainer;

@property (nonatomic, strong) ASIPithosObject *pithosObject;

@property (nonatomic, strong) NSArray *versions;

//  PithosObjectNode.m

//  pithos-macos

//

//

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

// without modification, are permitted provided that the following

#import "PithosObjectNodeInfoController.h"

@implementation PithosObjectNode

@synthesize isPublic, translatedModifiedBy, translatedPermissions;

#pragma mark -

#pragma mark Object Lifecycle

- (id)initWithPithosAccountManager:(PithosAccount *)aPithosAccountManager

                   pithosContainer:(ASIPithosContainer *)aPithosContainer

                      pithosObject:(ASIPithosObject *)aPithosObject {

    if ((self = [super initWithPithosAccountManager:aPithosAccountManager])) {

        isLeafItem = YES;

        self.pithosContainer = aPithosContainer;

        self.pithosObject = aPithosObject;

#pragma mark -

#pragma mark Properties

- (NSString *)url {

}

- (NSArray *)children {

        if (applyMetadataObjectRequest == nil) {

            [[pithosNodeInfoController window] makeFirstResponder:nil];

            if (sharingAccount) {

                                                                                                  containerName:pithosContainer.name

                                                                                                     objectName:pithosObject.name

                                                                                                contentEncoding:nil

                                                                                                       isPublic:(isPublic ? ASIPithosObjectRequestPublicTrue : ASIPithosObjectRequestPublicFalse)

                                                                                                       metadata:pithosObject.metadata

                                                                                                         update:NO];

            } else {

                NSMutableArray *permissions = [NSMutableArray array];

                if (translatedPermissions.count) {

                }

                pithosObject.permissions = permissions;

                                                                                                  containerName:pithosContainer.name

                                                                                                     objectName:pithosObject.name

                                                                                                contentEncoding:pithosObject.contentEncoding

- (void)refreshInfo {

    @synchronized(self) {

        if (refreshMetadataObjectRequest == nil) {

                                                                                          containerName:pithosContainer.name

                                                                                             objectName:pithosObject.name];

            if (sharingAccount)

            refreshMetadataObjectRequest.delegate = self;

            refreshMetadataObjectRequest.didFinishSelector = @selector(performRequestFinishedDelegateInBackground:);

            refreshMetadataObjectRequest.didFailSelector = @selector(performRequestFailedDelegateInBackground:);

- (void)refreshVersions {

    @synchronized(self) {

        if (refreshVersionsObjectRequest == nil) {

                                                                                          containerName:pithosContainer.name

                                                                                             objectName:pithosObject.name];

            if (sharingAccount)

            refreshVersionsObjectRequest.delegate = self;

            refreshVersionsObjectRequest.didFinishSelector = @selector(performRequestFinishedDelegateInBackground:);

            refreshVersionsObjectRequest.didFailSelector = @selector(performRequestFailedDelegateInBackground:);

//  PithosPreferencesController.h

//  pithos-macos

//

//

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

// without modification, are permitted provided that the following

//  PithosPreferencesController.m

//  pithos-macos

//

//

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

// without modification, are permitted provided that the following

            return;

        } else {

            [tmpPithosAccount updateServicesFromServiceCatalogRequest:serviceCatalogRequest];

            self.manual = tmpPithosAccount.manual;

            self.pithosObjectStoreURLString = tmpPithosAccount.pithosObjectStoreURLString;

            self.astakosAccountURLString = tmpPithosAccount.astakosAccountURLString;

            return;

        } else {

            [tmpPithosAccount updateServicesFromServiceCatalogRequest:serviceCatalogRequest];

            self.manual = tmpPithosAccount.manual;

            self.pithosObjectStoreURLString = tmpPithosAccount.pithosObjectStoreURLString;

            self.astakosAccountURLString = tmpPithosAccount.astakosAccountURLString;

                                             authToken:authToken

                                              authUser:authUser

                                       ignoreSSLErrors:ignoreSSLErrors];

        self.displayname = [selectedPithosAccount displaynameForUUID:authUser safe:NO];

        [self updateAuthorization];

    }

        [delegate showPithosBrowser:self];

    }

    if ([selectedPithosAccount isEqualTo:delegate.currentPithosAccount])

}

- (IBAction)authorizationCancel:(id)server {

//  PithosSharingAccountsNode.h

//  pithos-macos

//

//

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

// without modification, are permitted provided that the following

#import "PithosNode.h"

@class ASIPithosRequest;

@interface PithosSharingAccountsNode : PithosNode {

    ASIPithosRequest *sharingAccountsRequest;

}

@property(nonatomic, strong) ASIPithosRequest *sharingAccountsRequest;

@end

//  PithosAccountNode.m

//  pithos-macos

//

//

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

// without modification, are permitted provided that the following

#import "PithosActivityFacility.h"

@implementation PithosSharingAccountsNode

#pragma mark -

#pragma mark Object Lifecycle

    if ((self = [super initWithPithosAccountManager:aPithosAccountManager])) {

        self.sharingAccount = @"";

    }

    return self;

}

#pragma mark -

}

- (NSString *)url {

}

- (NSArray *)children {

    @synchronized(self) {

        switch (freshness) {

            case PithosNodeStateFresh:

                break;

            case PithosNodeStateRefreshNeeded:

                freshness = PithosNodeStateRefreshing;

                sharingAccountsRequest.delegate = self;

                sharingAccountsRequest.didFinishSelector = @selector(performRequestFinishedDelegateInBackground:);

                sharingAccountsRequest.didFailSelector = @selector(performRequestFailedDelegateInBackground:);

                    newChildren = [[NSMutableArray alloc] init];

                    NSMutableIndexSet *keptNodes = [NSMutableIndexSet indexSet];

                    for (ASIPithosAccount *account in sharingAccounts) {

                            node.parent = self;

                            node.shared = shared;

                            node.sharingAccount = account.name;

                [self postChildrenUpdatedNotificationName];

            } else {

                // Do an additional request to fetch more objects

                                                                                               limit:0

                                                                                              marker:[[someSharingAccounts lastObject] name]];

                sharingAccountsRequest.delegate = self;

//  PithosSubdirNode.h

//  pithos-macos

//

//

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

// without modification, are permitted provided that the following

}

- (id)initWithPithosAccountManager:(PithosAccount *)aPithosAccountManager

                   pithosContainer:(ASIPithosContainer *)aPithosContainer

                      pithosObject:(ASIPithosObject *)aPithosObject;

//  PithosSubdirNode.m

//  pithos-macos

//

//

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

// without modification, are permitted provided that the following

#pragma mark Object Lifecycle

- (id)initWithPithosAccountManager:(PithosAccount *)aPithosAccountManager

                   pithosContainer:(ASIPithosContainer *)aPithosContainer

                      pithosObject:(ASIPithosObject *)aPithosObject {

    if ((self = [super initWithPithosAccountManager:aPithosAccountManager])) {

        refreshParent = NO;