private string[] GetRemoteSubtitlePath(LocalItem item, MediaStream stream, IServerSyncProvider provider, SyncTarget target) { var filename = GetSubtitleSaveFileName(item, stream.Language, stream.IsForced) + "." + stream.Codec.ToLower(); var pathParts = item.LocalPath.Split(PathSeparatorChar); var list = pathParts.Take(pathParts.Length - 1).ToList(); list.Add(filename); return(list.ToArray()); }
private async Task <SendFileResult> SendFile(IServerSyncProvider provider, string inputPath, LocalItem item, SyncTarget target, CancellationToken cancellationToken) { using (var stream = _fileSystem.GetFileStream(inputPath, FileMode.Open, FileAccess.Read, FileShare.Read, true)) { return(await provider.SendFile(stream, item.LocalPath, target, new Progress <double>(), cancellationToken).ConfigureAwait(false)); } }
private async Task <List <ItemFileInfo> > GetFiles(IServerSyncProvider provider, LocalItem item, SyncTarget target, CancellationToken cancellationToken) { var path = item.LocalPath; path = provider.GetParentDirectoryPath(path, target); var list = await provider.GetFileSystemEntries(path, target, cancellationToken).ConfigureAwait(false); var itemFiles = new List <ItemFileInfo>(); var name = Path.GetFileNameWithoutExtension(item.LocalPath); foreach (var file in list.Where(f => f.Name.Contains(name))) { var itemFile = new ItemFileInfo { Path = file.Path, Name = file.Name }; if (IsSubtitleFile(file.Name)) { itemFile.Type = ItemFileType.Subtitles; } itemFiles.Add(itemFile); } return(itemFiles); }
public Task <List <LocalItem> > GetItemsBySyncJobItemId(SyncTarget target, string serverId, string syncJobItemId) { return(GetData(false, items => items.Where(i => string.Equals(i.ServerId, serverId, StringComparison.OrdinalIgnoreCase) && string.Equals(i.SyncJobItemId, syncJobItemId, StringComparison.OrdinalIgnoreCase)).ToList())); }
public Task <Stream> GetFile(string id, SyncTarget target, IProgress <double> progress, CancellationToken cancellationToken) { return(Task.FromResult(_fileSystem.OpenRead(id))); }
public string GetFullPath(IEnumerable <string> path, SyncTarget target) { return("/" + string.Join("/", path)); }
public Task Delete(SyncTarget target, string id) { return(UpdateData(items => items.Where(i => !string.Equals(i.Id, id, StringComparison.OrdinalIgnoreCase)).ToList())); }
public Task DeleteFile(string id, SyncTarget target, CancellationToken cancellationToken) { var googleCredentials = GetGoogleCredentials(target); return(_googleDriveService.DeleteFile(id, googleCredentials, cancellationToken)); }
private IEnumerable <SyncQualityOption> GetQualityOptions(ISyncProvider provider, SyncTarget target) { var hasQuality = provider as IHasSyncQuality; if (hasQuality != null) { return(hasQuality.GetQualityOptions(target)); } // Default options for providers that don't override return(new List <SyncQualityOption> { new SyncQualityOption { Name = "High", Id = "high", IsDefault = true }, new SyncQualityOption { Name = "Medium", Id = "medium" }, new SyncQualityOption { Name = "Low", Id = "low" }, new SyncQualityOption { Name = "Custom", Id = "custom" } }); }
private IEnumerable <SyncQualityOption> GetQualityOptions(ISyncProvider provider, SyncTarget target, User user) { var hasQuality = provider as IHasSyncQuality; if (hasQuality != null) { var options = hasQuality.GetQualityOptions(target); if (user != null && !user.Policy.EnableSyncTranscoding) { options = options.Where(i => i.IsOriginalQuality); } return(options); } // Default options for providers that don't override return(new List <SyncQualityOption> { new SyncQualityOption { Name = "High", Id = "high", IsDefault = true }, new SyncQualityOption { Name = "Medium", Id = "medium" }, new SyncQualityOption { Name = "Low", Id = "low" }, new SyncQualityOption { Name = "Custom", Id = "custom" } }); }
public string GetFullPath(IEnumerable <string> path, SyncTarget target) { return(Path.Combine(path.ToArray())); }
public SyncAction(SyncActionType syncActionType, SyncTarget syncTarget) { this.SyncActionType = syncActionType; this.SyncTarget = syncTarget; Guid = Guid.NewGuid(); }
public LocalItem CreateLocalItem(IServerSyncProvider provider, SyncedItem syncedItem, SyncJob job, SyncTarget target, BaseItemDto libraryItem, string serverId, string serverName, string originalFileName) { var path = GetDirectoryPath(provider, job, syncedItem, libraryItem, serverName); path.Add(GetLocalFileName(provider, libraryItem, originalFileName)); var localPath = string.Join(PathSeparatorString, path.ToArray()); foreach (var mediaSource in libraryItem.MediaSources) { mediaSource.Path = localPath; mediaSource.Protocol = MediaProtocol.File; } return(new LocalItem { Item = libraryItem, ItemId = libraryItem.Id, ServerId = serverId, LocalPath = localPath, Id = GetLocalId(syncedItem.SyncJobItemId, libraryItem.Id), SyncJobItemId = syncedItem.SyncJobItemId }); }
private async Task <SyncedFileInfo> SendFile(IServerSyncProvider provider, string inputPath, string[] pathParts, SyncTarget target, SyncOptions options, IProgress <double> progress, CancellationToken cancellationToken) { _logger.Debug("Sending {0} to {1}. Remote path: {2}", inputPath, provider.Name, string.Join("/", pathParts)); var supportsDirectCopy = provider as ISupportsDirectCopy; if (supportsDirectCopy != null) { return(await supportsDirectCopy.SendFile(inputPath, pathParts, target, progress, cancellationToken).ConfigureAwait(false)); } using (var fileStream = _fileSystem.GetFileStream(inputPath, FileMode.Open, FileAccess.Read, FileShare.Read, true)) { Stream stream = fileStream; if (options.UploadSpeedLimitBytes > 0 && provider is IRemoteSyncProvider) { stream = new ThrottledStream(stream, options.UploadSpeedLimitBytes); } return(await provider.SendFile(stream, pathParts, target, progress, cancellationToken).ConfigureAwait(false)); } }
public Task <QueryResult <FileSystemMetadata> > GetFiles(SyncTarget target, CancellationToken cancellationToken) { var syncAccount = _configurationRetriever.GetSyncAccount(target.Id); return(FindFilesMetadata(syncAccount.AccessToken, cancellationToken)); }
private IEnumerable <SyncProfileOption> GetProfileOptions(ISyncProvider provider, SyncTarget target) { var hasQuality = provider as IHasSyncQuality; if (hasQuality != null) { return(hasQuality.GetProfileOptions(target)); } var list = new List <SyncProfileOption>(); list.Add(new SyncProfileOption { Name = "Original", Id = "Original", Description = "Syncs original files as-is.", EnableQualityOptions = false }); list.Add(new SyncProfileOption { Name = "Baseline", Id = "baseline", Description = "Designed for compatibility with all devices, including web browsers. Targets H264/AAC video and MP3 audio." }); list.Add(new SyncProfileOption { Name = "General", Id = "general", Description = "Designed for compatibility with Chromecast, Roku, Smart TV's, and other similar devices. Targets H264/AAC/AC3 video and MP3 audio.", IsDefault = true }); return(list); }
public async Task <SyncedFileInfo> SendFile(SyncJob syncJob, string originalMediaPath, Stream inputStream, bool isMedia, string[] outputPathParts, SyncTarget target, IProgress <double> progress, CancellationToken cancellationToken) { var path = GetFullPath(outputPathParts, target); _logger.Debug("Sending file {0} to {1}", path, target.Name); var syncAccount = _configurationRetriever.GetSyncAccount(target.Id); await UploadFile(path, inputStream, progress, syncAccount.AccessToken, cancellationToken).ConfigureAwait(false); return(new SyncedFileInfo { Id = path, Path = path, Protocol = MediaProtocol.Http }); }
public ISyncDataProvider GetDataProvider(IServerSyncProvider provider, SyncTarget target) { return(_dataProviders.GetOrAdd(target.Id, key => new TargetDataProvider(provider, target, _appHost.SystemId, _logger, _json, _fileSystem, _config.CommonApplicationPaths))); }
public DeviceProfile GetDeviceProfile(SyncTarget target) { return(new DeviceProfile()); }
private OneDriveCredentials CreateOneDriveCredentials(SyncTarget target) { return(new OneDriveCredentials(_configurationRetriever, _liveAuthenticationApi, target)); }
public Task <LocalItem> Get(SyncTarget target, string id) { return(GetData(true, items => items.FirstOrDefault(i => string.Equals(i.Id, id, StringComparison.OrdinalIgnoreCase)))); }
private async Task <QueryResult <FileMetadata> > TryGetFiles(FileQuery query, SyncTarget target, CancellationToken cancellationToken) { var oneDriveCredentials = CreateOneDriveCredentials(target); if (!string.IsNullOrEmpty(query.Id)) { return(await GetFileById(query.Id, oneDriveCredentials, cancellationToken)); } if (query.FullPath != null && query.FullPath.Length > 0) { var path = GetFullPath(query.FullPath); return(await GetFileByPath(path, oneDriveCredentials, cancellationToken)); } return(await GetAllFiles(oneDriveCredentials, cancellationToken)); }
public async Task <SyncedFileInfo> SendFile(Stream stream, string[] remotePath, SyncTarget target, IProgress <double> progress, CancellationToken cancellationToken) { var fullPath = GetFullPath(remotePath, target); _fileSystem.CreateDirectory(Path.GetDirectoryName(fullPath)); _logger.Debug("Folder sync saving stream to {0}", fullPath); using (var fileStream = _fileSystem.GetFileStream(fullPath, FileMode.Create, FileAccess.Write, FileShare.Read, true)) { await stream.CopyToAsync(fileStream).ConfigureAwait(false); return(GetSyncedFileInfo(fullPath)); } }
public async Task <SyncedFileInfo> SendFile(Stream stream, string[] pathParts, SyncTarget target, IProgress <double> progress, CancellationToken cancellationToken) { string path = GetFullPath(pathParts); _logger.Debug("Sending file {0} to {1}", path, target.Name); var oneDriveCredentials = CreateOneDriveCredentials(target); await CreateFolderHierarchy(pathParts, oneDriveCredentials, cancellationToken); var uploadSession = await _oneDriveApi.CreateUploadSession(path, oneDriveCredentials, cancellationToken); var id = await UploadFile(uploadSession.uploadUrl, stream, oneDriveCredentials, cancellationToken); return(new SyncedFileInfo { Id = id, Path = path, Protocol = MediaProtocol.Http }); }
private async Task GetItem(IServerSyncProvider provider, ISyncDataProvider dataProvider, SyncTarget target, string serverId, SyncedItem jobItem, IProgress <double> progress, CancellationToken cancellationToken) { var libraryItem = jobItem.Item; var internalSyncJobItem = _syncManager.GetJobItem(jobItem.SyncJobItemId); var fileTransferProgress = new ActionableProgress <double>(); fileTransferProgress.RegisterAction(pct => progress.Report(pct * .92)); var localItem = CreateLocalItem(provider, jobItem.SyncJobId, jobItem.SyncJobItemId, target, libraryItem, serverId, jobItem.OriginalFileName); await _syncManager.ReportSyncJobItemTransferBeginning(internalSyncJobItem.Id); var transferSuccess = false; Exception transferException = null; try { var sendFileResult = await SendFile(provider, internalSyncJobItem.OutputPath, localItem, target, cancellationToken).ConfigureAwait(false); if (localItem.Item.MediaSources != null) { var mediaSource = localItem.Item.MediaSources.FirstOrDefault(); if (mediaSource != null) { mediaSource.Path = sendFileResult.Path; mediaSource.Protocol = sendFileResult.Protocol; mediaSource.SupportsTranscoding = false; } } // Create db record await dataProvider.AddOrUpdate(target, localItem).ConfigureAwait(false); progress.Report(92); transferSuccess = true; progress.Report(99); } catch (Exception ex) { _logger.ErrorException("Error transferring sync job file", ex); transferException = ex; } if (transferSuccess) { await _syncManager.ReportSyncJobItemTransferred(jobItem.SyncJobItemId).ConfigureAwait(false); } else { await _syncManager.ReportSyncJobItemTransferFailed(jobItem.SyncJobItemId).ConfigureAwait(false); throw transferException; } }
public async Task <SyncedFileInfo> SendFile(Stream stream, string[] pathParts, SyncTarget target, IProgress <double> progress, CancellationToken cancellationToken) { _logger.Debug("Sending file {0} to {1}", string.Join("/", pathParts), target.Name); var syncAccount = _configurationRetriever.GetSyncAccount(target.Id); var googleCredentials = GetGoogleCredentials(target); var file = await _googleDriveService.UploadFile(stream, pathParts, syncAccount.FolderId, googleCredentials, progress, cancellationToken); return(new SyncedFileInfo { Path = file.Item2, Protocol = MediaProtocol.Http, Id = file.Item1 }); }
public LocalItem CreateLocalItem(IServerSyncProvider provider, string syncJobId, string syncJobItemId, SyncTarget target, BaseItemDto libraryItem, string serverId, string originalFileName) { var path = GetDirectoryPath(provider, syncJobId, libraryItem, serverId); path.Add(GetLocalFileName(provider, libraryItem, originalFileName)); var localPath = provider.GetFullPath(path, target); foreach (var mediaSource in libraryItem.MediaSources) { mediaSource.Path = localPath; mediaSource.Protocol = MediaProtocol.File; } return(new LocalItem { Item = libraryItem, ItemId = libraryItem.Id, ServerId = serverId, LocalPath = localPath, Id = GetLocalId(syncJobItemId, libraryItem.Id) }); }
public Task <QueryResult <FileSystemMetadata> > GetFiles(string[] directoryPathParts, SyncTarget target, CancellationToken cancellationToken) { var syncAccount = _configurationRetriever.GetSyncAccount(target.Id); var path = FindPathFromFileQuery(directoryPathParts, target); return(FilesInFolder(path, syncAccount.AccessToken, cancellationToken)); }
public IEnumerable <SyncProfileOption> GetProfileOptions(SyncTarget target) { return(new List <SyncProfileOption>()); }
private async Task SendSubtitles(LocalItem localItem, MediaSourceInfo mediaSource, IServerSyncProvider provider, ISyncDataProvider dataProvider, SyncTarget target, SyncOptions options, CancellationToken cancellationToken) { var failedSubtitles = new List <MediaStream>(); var requiresSave = false; foreach (var mediaStream in mediaSource.MediaStreams .Where(i => i.Type == MediaStreamType.Subtitle && i.IsExternal) .ToList()) { try { var remotePath = GetRemoteSubtitlePath(localItem, mediaStream, provider, target); var sendFileResult = await SendFile(provider, mediaStream.Path, remotePath, target, options, new Progress <double>(), cancellationToken).ConfigureAwait(false); // This is the path that will be used when talking to the provider mediaStream.ExternalId = sendFileResult.Id; // Keep track of all additional files for cleanup later. localItem.AdditionalFiles.Add(sendFileResult.Id); // This is the public path clients will use mediaStream.Path = sendFileResult.Path; requiresSave = true; } catch (Exception ex) { _logger.ErrorException("Error sending subtitle stream", ex); failedSubtitles.Add(mediaStream); } } if (failedSubtitles.Count > 0) { mediaSource.MediaStreams = mediaSource.MediaStreams.Except(failedSubtitles).ToList(); requiresSave = true; } if (requiresSave) { await dataProvider.AddOrUpdate(target, localItem).ConfigureAwait(false); } }