Proyectos de Subversion Iphone Microlearning

// Copyright 2019 Google
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#import "Crashlytics/Crashlytics/Models/FIRCLSFileManager.h"

#import "Crashlytics/Crashlytics/Components/FIRCLSApplication.h"
#import "Crashlytics/Crashlytics/Components/FIRCLSCrashedMarkerFile.h"
#import "Crashlytics/Crashlytics/Helpers/FIRCLSLogger.h"
#import "Crashlytics/Crashlytics/Models/FIRCLSInternalReport.h"

NSString *const FIRCLSCacheDirectoryName = @"com.crashlytics.data";
NSString *const FIRCLSCacheVersion = @"v5";
NSString *const FIRCLSMetricKitDiagnosticPath = @"/MetricKit/Diagnostics/";

@interface FIRCLSFileManager () {
  NSString *_rootPath;
  NSString *_cachesPath;
}
@property(nonatomic) BOOL crashFileMarkerExists;

@end

@implementation FIRCLSFileManager

- (instancetype)init {
  self = [super init];
  if (!self) {
    return nil;
  }

  _underlyingFileManager = [NSFileManager defaultManager];

  NSString *path =
      [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES) lastObject];
  _cachesPath = [path copy];
  path = [path stringByAppendingPathComponent:FIRCLSCacheDirectoryName];
  path = [path stringByAppendingPathComponent:[self pathNamespace]];
  _rootPath = [path copy];

  _crashFileMarkerExists = NO;
  return self;
}

#pragma mark - Core API

- (BOOL)fileExistsAtPath:(NSString *)path {
  return [_underlyingFileManager fileExistsAtPath:path];
}

- (BOOL)createFileAtPath:(NSString *)path
                contents:(nullable NSData *)data
              attributes:(nullable NSDictionary<NSFileAttributeKey, id> *)attr {
  return [_underlyingFileManager createFileAtPath:path contents:data attributes:attr];
}

- (BOOL)createDirectoryAtPath:(NSString *)path {
  NSDictionary *attributes;
  NSError *error;

  attributes = @{NSFilePosixPermissions : [NSNumber numberWithShort:0755]};
  error = nil;

  if (![[self underlyingFileManager] createDirectoryAtPath:path
                               withIntermediateDirectories:YES
                                                attributes:attributes
                                                     error:&error]) {
    FIRCLSErrorLog(@"Unable to create directory %@", error);
    return NO;
  }

  return YES;
}

- (BOOL)removeItemAtPath:(NSString *)path {
  NSError *error;

  error = nil;
  if (![[self underlyingFileManager] removeItemAtPath:path error:&error] || !path) {
    FIRCLSErrorLog(@"Failed to remove file %@: %@", path, error);

    return NO;
  }

  return YES;
}

- (BOOL)removeContentsOfDirectoryAtPath:(NSString *)path {
  __block BOOL success = YES;

  // only return true if we were able to remove every item in the directory (or it was empty)

  [self enumerateFilesInDirectory:path
                       usingBlock:^(NSString *filePath, NSString *extension) {
                         success = [self removeItemAtPath:filePath] && success;
                       }];

  return success;
}

- (BOOL)moveItemAtPath:(NSString *)path toDirectory:(NSString *)destDir {
  NSString *destPath;
  NSError *error;

  destPath = [destDir stringByAppendingPathComponent:[path lastPathComponent]];
  error = nil;

  if (!path || !destPath) {
    FIRCLSErrorLog(@"Failed to move file, inputs invalid");

    return NO;
  }

  if (![[self underlyingFileManager] moveItemAtPath:path toPath:destPath error:&error]) {
    FIRCLSErrorLog(@"Failed to move file: %@", error);

    return NO;
  }

  return YES;
}

- (BOOL)didCrashOnPreviousExecution {
  static dispatch_once_t checkCrashFileMarketExistsOnceToken;
  dispatch_once(&checkCrashFileMarketExistsOnceToken, ^{
    NSString *crashedMarkerFileName = [NSString stringWithUTF8String:FIRCLSCrashedMarkerFileName];
    NSString *crashedMarkerFileFullPath =
        [[self rootPath] stringByAppendingPathComponent:crashedMarkerFileName];
    self.crashFileMarkerExists = [self fileExistsAtPath:crashedMarkerFileFullPath];
  });
  return self.crashFileMarkerExists;
}

- (BOOL)metricKitDiagnosticFileExists {
  NSArray *contentsOfMetricKitDirectory = [self
      contentsOfDirectory:[_cachesPath stringByAppendingString:FIRCLSMetricKitDiagnosticPath]];
  return ([contentsOfMetricKitDirectory count] > 0);
}

- (void)createEmptyMetricKitFile:(NSString *)reportPath {
  NSString *metricKitFile =
      [reportPath stringByAppendingPathComponent:FIRCLSMetricKitFatalReportFile];
  [self createFileAtPath:metricKitFile contents:nil attributes:nil];
}

- (void)enumerateFilesInDirectory:(NSString *)directory
                       usingBlock:(void (^)(NSString *filePath, NSString *extension))block {
  for (NSString *path in [[self underlyingFileManager] contentsOfDirectoryAtPath:directory
                                                                           error:nil]) {
    NSString *extension;
    NSString *fullPath;

    // Skip files that start with a dot.  This is important, because if you try to move a .DS_Store
    // file, it will fail if the target directory also has a .DS_Store file in it.  Plus, its
    // wasteful, because we don't care about dot files.
    if ([path hasPrefix:@"."]) {
      continue;
    }

    extension = [path pathExtension];
    fullPath = [directory stringByAppendingPathComponent:path];
    if (block) {
      block(fullPath, extension);
    }
  }
}

- (NSNumber *)fileSizeAtPath:(NSString *)path {
  NSError *error = nil;
  NSDictionary *attrs = [[self underlyingFileManager] attributesOfItemAtPath:path error:&error];

  if (!attrs) {
    FIRCLSErrorLog(@"Unable to read file size: %@", error);
    return nil;
  }

  return [attrs objectForKey:NSFileSize];
}

- (NSArray *)contentsOfDirectory:(NSString *)path {
  NSMutableArray *array = [NSMutableArray array];

  [self enumerateFilesInDirectory:path
                       usingBlock:^(NSString *filePath, NSString *extension) {
                         [array addObject:filePath];
                       }];

  return [array copy];
}

#pragma - Properties
- (NSString *)pathNamespace {
  return FIRCLSApplicationGetBundleIdentifier();
}

- (NSString *)versionedPath {
  return [[self rootPath] stringByAppendingPathComponent:FIRCLSCacheVersion];
}

#pragma - Settings Paths

// This path should be different than the structurePath because the
// settings download operations will delete the settings directory,
// which would delete crash reports if these were the same
- (NSString *)settingsDirectoryPath {
  return [[self versionedPath] stringByAppendingPathComponent:@"settings"];
}

- (NSString *)settingsFilePath {
  return [[self settingsDirectoryPath] stringByAppendingPathComponent:@"settings.json"];
}

- (NSString *)settingsCacheKeyPath {
  return [[self settingsDirectoryPath] stringByAppendingPathComponent:@"cache-key.json"];
}

#pragma - Report Paths
- (NSString *)structurePath {
  return [[self versionedPath] stringByAppendingPathComponent:@"reports"];
}

- (NSString *)activePath {
  return [[self structurePath] stringByAppendingPathComponent:@"active"];
}

- (NSString *)pendingPath {
  return [[self structurePath] stringByAppendingPathComponent:@"pending"];
}

- (NSString *)processingPath {
  return [[self structurePath] stringByAppendingPathComponent:@"processing"];
}

- (NSString *)preparedPath {
  return [[self structurePath] stringByAppendingPathComponent:@"prepared"];
}

- (NSArray *)activePathContents {
  return [self contentsOfDirectory:[self activePath]];
}

- (NSArray *)preparedPathContents {
  return [self contentsOfDirectory:[self preparedPath]];
}

- (NSArray *)processingPathContents {
  return [self contentsOfDirectory:[self processingPath]];
}

#pragma mark - Logic
- (BOOL)createReportDirectories {
  if (![self createDirectoryAtPath:[self activePath]]) {
    return NO;
  }

  if (![self createDirectoryAtPath:[self processingPath]]) {
    return NO;
  }

  if (![self createDirectoryAtPath:[self preparedPath]]) {
    return NO;
  }

  return YES;
}

- (NSString *)setupNewPathForExecutionIdentifier:(NSString *)identifier {
  NSString *path = [[self activePath] stringByAppendingPathComponent:identifier];

  if (![self createDirectoryAtPath:path]) {
    return nil;
  }

  return path;
}

- (BOOL)moveItemAtPath:(NSString *)srcPath toPath:(NSString *)dstPath error:(NSError **)error {
  return [self.underlyingFileManager moveItemAtPath:srcPath toPath:dstPath error:error];
}

// Wrapper over NSData so the method can be mocked for unit tests
- (NSData *)dataWithContentsOfFile:(NSString *)path {
  return [NSData dataWithContentsOfFile:path];
}

@end