mirror of
https://github.com/jellyfin/jellyfin.git
synced 2026-03-22 10:06:40 +00:00
move classes to portable project
This commit is contained in:
Luke Pulverenti
@@ -1,118 +0,0 @@
|
||||
using MediaBrowser.Controller.Devices;
|
||||
using MediaBrowser.Controller.Sync;
|
||||
using MediaBrowser.Model.Devices;
|
||||
using MediaBrowser.Model.Dlna;
|
||||
using MediaBrowser.Model.Sync;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
|
||||
namespace MediaBrowser.Server.Implementations.Sync
|
||||
{
|
||||
public class AppSyncProvider : ISyncProvider, IHasUniqueTargetIds, IHasSyncQuality, IHasDuplicateCheck
|
||||
{
|
||||
private readonly IDeviceManager _deviceManager;
|
||||
|
||||
public AppSyncProvider(IDeviceManager deviceManager)
|
||||
{
|
||||
_deviceManager = deviceManager;
|
||||
}
|
||||
|
||||
public IEnumerable<SyncTarget> GetSyncTargets(string userId)
|
||||
{
|
||||
return _deviceManager.GetDevices(new DeviceQuery
|
||||
{
|
||||
SupportsSync = true,
|
||||
UserId = userId
|
||||
|
||||
}).Items.Select(i => new SyncTarget
|
||||
{
|
||||
Id = i.Id,
|
||||
Name = i.Name
|
||||
});
|
||||
}
|
||||
|
||||
public DeviceProfile GetDeviceProfile(SyncTarget target, string profile, string quality)
|
||||
{
|
||||
var caps = _deviceManager.GetCapabilities(target.Id);
|
||||
|
||||
var deviceProfile = caps == null || caps.DeviceProfile == null ? new DeviceProfile() : caps.DeviceProfile;
|
||||
deviceProfile.MaxStaticBitrate = SyncHelper.AdjustBitrate(deviceProfile.MaxStaticBitrate, quality);
|
||||
|
||||
return deviceProfile;
|
||||
}
|
||||
|
||||
public string Name
|
||||
{
|
||||
get { return "Mobile Sync"; }
|
||||
}
|
||||
|
||||
public IEnumerable<SyncTarget> GetAllSyncTargets()
|
||||
{
|
||||
return _deviceManager.GetDevices(new DeviceQuery
|
||||
{
|
||||
SupportsSync = true
|
||||
|
||||
}).Items.Select(i => new SyncTarget
|
||||
{
|
||||
Id = i.Id,
|
||||
Name = i.Name
|
||||
});
|
||||
}
|
||||
|
||||
public IEnumerable<SyncQualityOption> GetQualityOptions(SyncTarget target)
|
||||
{
|
||||
return new List<SyncQualityOption>
|
||||
{
|
||||
new SyncQualityOption
|
||||
{
|
||||
Name = "Original",
|
||||
Id = "original",
|
||||
Description = "Syncs original files as-is, regardless of whether the device is capable of playing them or not."
|
||||
},
|
||||
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 IEnumerable<SyncProfileOption> GetProfileOptions(SyncTarget target)
|
||||
{
|
||||
return new List<SyncProfileOption>();
|
||||
}
|
||||
|
||||
public SyncJobOptions GetSyncJobOptions(SyncTarget target, string profile, string quality)
|
||||
{
|
||||
var isConverting = !string.Equals(quality, "original", StringComparison.OrdinalIgnoreCase);
|
||||
|
||||
return new SyncJobOptions
|
||||
{
|
||||
DeviceProfile = GetDeviceProfile(target, profile, quality),
|
||||
IsConverting = isConverting
|
||||
};
|
||||
}
|
||||
|
||||
public bool AllowDuplicateJobItem(SyncJobItem original, SyncJobItem duplicate)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,302 +0,0 @@
|
||||
using MediaBrowser.Model.Dlna;
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace MediaBrowser.Server.Implementations.Sync
|
||||
{
|
||||
public class CloudSyncProfile : DeviceProfile
|
||||
{
|
||||
public CloudSyncProfile(bool supportsAc3, bool supportsDca)
|
||||
{
|
||||
Name = "Cloud Sync";
|
||||
|
||||
MaxStreamingBitrate = 20000000;
|
||||
MaxStaticBitrate = 20000000;
|
||||
|
||||
var mkvAudio = "aac,mp3";
|
||||
var mp4Audio = "aac";
|
||||
|
||||
if (supportsAc3)
|
||||
{
|
||||
mkvAudio += ",ac3";
|
||||
mp4Audio += ",ac3";
|
||||
}
|
||||
|
||||
if (supportsDca)
|
||||
{
|
||||
mkvAudio += ",dca,dts";
|
||||
}
|
||||
|
||||
var videoProfile = "high|main|baseline|constrained baseline";
|
||||
var videoLevel = "40";
|
||||
|
||||
DirectPlayProfiles = new[]
|
||||
{
|
||||
//new DirectPlayProfile
|
||||
//{
|
||||
// Container = "mkv",
|
||||
// VideoCodec = "h264,mpeg4",
|
||||
// AudioCodec = mkvAudio,
|
||||
// Type = DlnaProfileType.Video
|
||||
//},
|
||||
new DirectPlayProfile
|
||||
{
|
||||
Container = "mp4,mov,m4v",
|
||||
VideoCodec = "h264,mpeg4",
|
||||
AudioCodec = mp4Audio,
|
||||
Type = DlnaProfileType.Video
|
||||
},
|
||||
new DirectPlayProfile
|
||||
{
|
||||
Container = "mp3",
|
||||
Type = DlnaProfileType.Audio
|
||||
}
|
||||
};
|
||||
|
||||
ContainerProfiles = new[]
|
||||
{
|
||||
new ContainerProfile
|
||||
{
|
||||
Type = DlnaProfileType.Video,
|
||||
Conditions = new []
|
||||
{
|
||||
new ProfileCondition
|
||||
{
|
||||
Condition = ProfileConditionType.NotEquals,
|
||||
Property = ProfileConditionValue.NumAudioStreams,
|
||||
Value = "0",
|
||||
IsRequired = false
|
||||
},
|
||||
new ProfileCondition
|
||||
{
|
||||
Condition = ProfileConditionType.EqualsAny,
|
||||
Property = ProfileConditionValue.NumVideoStreams,
|
||||
Value = "1",
|
||||
IsRequired = false
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
var codecProfiles = new List<CodecProfile>
|
||||
{
|
||||
new CodecProfile
|
||||
{
|
||||
Type = CodecType.Video,
|
||||
Codec = "h264",
|
||||
Conditions = new []
|
||||
{
|
||||
new ProfileCondition
|
||||
{
|
||||
Condition = ProfileConditionType.LessThanEqual,
|
||||
Property = ProfileConditionValue.VideoBitDepth,
|
||||
Value = "8",
|
||||
IsRequired = false
|
||||
},
|
||||
new ProfileCondition
|
||||
{
|
||||
Condition = ProfileConditionType.LessThanEqual,
|
||||
Property = ProfileConditionValue.Width,
|
||||
Value = "1920",
|
||||
IsRequired = true
|
||||
},
|
||||
new ProfileCondition
|
||||
{
|
||||
Condition = ProfileConditionType.LessThanEqual,
|
||||
Property = ProfileConditionValue.Height,
|
||||
Value = "1080",
|
||||
IsRequired = true
|
||||
},
|
||||
new ProfileCondition
|
||||
{
|
||||
Condition = ProfileConditionType.LessThanEqual,
|
||||
Property = ProfileConditionValue.RefFrames,
|
||||
Value = "4",
|
||||
IsRequired = false
|
||||
},
|
||||
new ProfileCondition
|
||||
{
|
||||
Condition = ProfileConditionType.LessThanEqual,
|
||||
Property = ProfileConditionValue.VideoFramerate,
|
||||
Value = "30",
|
||||
IsRequired = false
|
||||
},
|
||||
new ProfileCondition
|
||||
{
|
||||
Condition = ProfileConditionType.Equals,
|
||||
Property = ProfileConditionValue.IsAnamorphic,
|
||||
Value = "false",
|
||||
IsRequired = false
|
||||
},
|
||||
new ProfileCondition
|
||||
{
|
||||
Condition = ProfileConditionType.LessThanEqual,
|
||||
Property = ProfileConditionValue.VideoLevel,
|
||||
Value = videoLevel,
|
||||
IsRequired = false
|
||||
},
|
||||
new ProfileCondition
|
||||
{
|
||||
Condition = ProfileConditionType.EqualsAny,
|
||||
Property = ProfileConditionValue.VideoProfile,
|
||||
Value = videoProfile,
|
||||
IsRequired = false
|
||||
}
|
||||
}
|
||||
},
|
||||
new CodecProfile
|
||||
{
|
||||
Type = CodecType.Video,
|
||||
Codec = "mpeg4",
|
||||
Conditions = new []
|
||||
{
|
||||
new ProfileCondition
|
||||
{
|
||||
Condition = ProfileConditionType.LessThanEqual,
|
||||
Property = ProfileConditionValue.VideoBitDepth,
|
||||
Value = "8",
|
||||
IsRequired = false
|
||||
},
|
||||
new ProfileCondition
|
||||
{
|
||||
Condition = ProfileConditionType.LessThanEqual,
|
||||
Property = ProfileConditionValue.Width,
|
||||
Value = "1920",
|
||||
IsRequired = true
|
||||
},
|
||||
new ProfileCondition
|
||||
{
|
||||
Condition = ProfileConditionType.LessThanEqual,
|
||||
Property = ProfileConditionValue.Height,
|
||||
Value = "1080",
|
||||
IsRequired = true
|
||||
},
|
||||
new ProfileCondition
|
||||
{
|
||||
Condition = ProfileConditionType.LessThanEqual,
|
||||
Property = ProfileConditionValue.RefFrames,
|
||||
Value = "4",
|
||||
IsRequired = false
|
||||
},
|
||||
new ProfileCondition
|
||||
{
|
||||
Condition = ProfileConditionType.LessThanEqual,
|
||||
Property = ProfileConditionValue.VideoFramerate,
|
||||
Value = "30",
|
||||
IsRequired = false
|
||||
},
|
||||
new ProfileCondition
|
||||
{
|
||||
Condition = ProfileConditionType.Equals,
|
||||
Property = ProfileConditionValue.IsAnamorphic,
|
||||
Value = "false",
|
||||
IsRequired = false
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
codecProfiles.Add(new CodecProfile
|
||||
{
|
||||
Type = CodecType.VideoAudio,
|
||||
Codec = "ac3",
|
||||
Conditions = new[]
|
||||
{
|
||||
new ProfileCondition
|
||||
{
|
||||
Condition = ProfileConditionType.LessThanEqual,
|
||||
Property = ProfileConditionValue.AudioChannels,
|
||||
Value = "6",
|
||||
IsRequired = false
|
||||
},
|
||||
new ProfileCondition
|
||||
{
|
||||
Condition = ProfileConditionType.LessThanEqual,
|
||||
Property = ProfileConditionValue.AudioBitrate,
|
||||
Value = "320000",
|
||||
IsRequired = true
|
||||
},
|
||||
new ProfileCondition
|
||||
{
|
||||
Condition = ProfileConditionType.Equals,
|
||||
Property = ProfileConditionValue.IsSecondaryAudio,
|
||||
Value = "false",
|
||||
IsRequired = false
|
||||
}
|
||||
}
|
||||
});
|
||||
codecProfiles.Add(new CodecProfile
|
||||
{
|
||||
Type = CodecType.VideoAudio,
|
||||
Codec = "aac,mp3",
|
||||
Conditions = new[]
|
||||
{
|
||||
new ProfileCondition
|
||||
{
|
||||
Condition = ProfileConditionType.LessThanEqual,
|
||||
Property = ProfileConditionValue.AudioChannels,
|
||||
Value = "2",
|
||||
IsRequired = true
|
||||
},
|
||||
new ProfileCondition
|
||||
{
|
||||
Condition = ProfileConditionType.LessThanEqual,
|
||||
Property = ProfileConditionValue.AudioBitrate,
|
||||
Value = "320000",
|
||||
IsRequired = true
|
||||
},
|
||||
new ProfileCondition
|
||||
{
|
||||
Condition = ProfileConditionType.Equals,
|
||||
Property = ProfileConditionValue.IsSecondaryAudio,
|
||||
Value = "false",
|
||||
IsRequired = false
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
CodecProfiles = codecProfiles.ToArray();
|
||||
|
||||
SubtitleProfiles = new[]
|
||||
{
|
||||
new SubtitleProfile
|
||||
{
|
||||
Format = "srt",
|
||||
Method = SubtitleDeliveryMethod.External
|
||||
},
|
||||
new SubtitleProfile
|
||||
{
|
||||
Format = "vtt",
|
||||
Method = SubtitleDeliveryMethod.External
|
||||
}
|
||||
};
|
||||
|
||||
TranscodingProfiles = new[]
|
||||
{
|
||||
new TranscodingProfile
|
||||
{
|
||||
Container = "mp3",
|
||||
AudioCodec = "mp3",
|
||||
Type = DlnaProfileType.Audio,
|
||||
Context = EncodingContext.Static
|
||||
},
|
||||
|
||||
new TranscodingProfile
|
||||
{
|
||||
Container = "mp4",
|
||||
Type = DlnaProfileType.Video,
|
||||
AudioCodec = "aac",
|
||||
VideoCodec = "h264",
|
||||
Context = EncodingContext.Static
|
||||
},
|
||||
|
||||
new TranscodingProfile
|
||||
{
|
||||
Container = "jpeg",
|
||||
Type = DlnaProfileType.Photo,
|
||||
Context = EncodingContext.Static
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
using MediaBrowser.Model.Sync;
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace MediaBrowser.Server.Implementations.Sync
|
||||
{
|
||||
public interface IHasSyncQuality
|
||||
{
|
||||
/// <summary>
|
||||
/// Gets the device profile.
|
||||
/// </summary>
|
||||
/// <param name="target">The target.</param>
|
||||
/// <param name="profile">The profile.</param>
|
||||
/// <param name="quality">The quality.</param>
|
||||
/// <returns>DeviceProfile.</returns>
|
||||
SyncJobOptions GetSyncJobOptions(SyncTarget target, string profile, string quality);
|
||||
|
||||
/// <summary>
|
||||
/// Gets the quality options.
|
||||
/// </summary>
|
||||
/// <param name="target">The target.</param>
|
||||
/// <returns>IEnumerable<SyncQualityOption>.</returns>
|
||||
IEnumerable<SyncQualityOption> GetQualityOptions(SyncTarget target);
|
||||
|
||||
/// <summary>
|
||||
/// Gets the profile options.
|
||||
/// </summary>
|
||||
/// <param name="target">The target.</param>
|
||||
/// <returns>IEnumerable<SyncQualityOption>.</returns>
|
||||
IEnumerable<SyncProfileOption> GetProfileOptions(SyncTarget target);
|
||||
}
|
||||
}
|
||||
@@ -1,502 +0,0 @@
|
||||
using MediaBrowser.Common.Configuration;
|
||||
using MediaBrowser.Common.Progress;
|
||||
using MediaBrowser.Controller;
|
||||
using MediaBrowser.Controller.IO;
|
||||
using MediaBrowser.Controller.Sync;
|
||||
using MediaBrowser.Model.Dto;
|
||||
using MediaBrowser.Model.Entities;
|
||||
using MediaBrowser.Model.Logging;
|
||||
using MediaBrowser.Model.MediaInfo;
|
||||
using MediaBrowser.Model.Sync;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Globalization;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Security.Cryptography;
|
||||
using System.Text;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using MediaBrowser.Model.IO;
|
||||
using MediaBrowser.Common.IO;
|
||||
using MediaBrowser.Server.Implementations.IO;
|
||||
|
||||
namespace MediaBrowser.Server.Implementations.Sync
|
||||
{
|
||||
public class MediaSync
|
||||
{
|
||||
private readonly ISyncManager _syncManager;
|
||||
private readonly IServerApplicationHost _appHost;
|
||||
private readonly ILogger _logger;
|
||||
private readonly IFileSystem _fileSystem;
|
||||
private readonly IConfigurationManager _config;
|
||||
|
||||
public const string PathSeparatorString = "/";
|
||||
public const char PathSeparatorChar = '/';
|
||||
|
||||
public MediaSync(ILogger logger, ISyncManager syncManager, IServerApplicationHost appHost, IFileSystem fileSystem, IConfigurationManager config)
|
||||
{
|
||||
_logger = logger;
|
||||
_syncManager = syncManager;
|
||||
_appHost = appHost;
|
||||
_fileSystem = fileSystem;
|
||||
_config = config;
|
||||
}
|
||||
|
||||
public async Task Sync(IServerSyncProvider provider,
|
||||
ISyncDataProvider dataProvider,
|
||||
SyncTarget target,
|
||||
IProgress<double> progress,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
var serverId = _appHost.SystemId;
|
||||
var serverName = _appHost.FriendlyName;
|
||||
|
||||
await SyncData(provider, dataProvider, serverId, target, cancellationToken).ConfigureAwait(false);
|
||||
progress.Report(3);
|
||||
|
||||
var innerProgress = new ActionableProgress<double>();
|
||||
innerProgress.RegisterAction(pct =>
|
||||
{
|
||||
var totalProgress = pct * .97;
|
||||
totalProgress += 1;
|
||||
progress.Report(totalProgress);
|
||||
});
|
||||
await GetNewMedia(provider, dataProvider, target, serverId, serverName, innerProgress, cancellationToken);
|
||||
|
||||
// Do the data sync twice so the server knows what was removed from the device
|
||||
await SyncData(provider, dataProvider, serverId, target, cancellationToken).ConfigureAwait(false);
|
||||
|
||||
progress.Report(100);
|
||||
}
|
||||
|
||||
private async Task SyncData(IServerSyncProvider provider,
|
||||
ISyncDataProvider dataProvider,
|
||||
string serverId,
|
||||
SyncTarget target,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
var localItems = await dataProvider.GetLocalItems(target, serverId).ConfigureAwait(false);
|
||||
var remoteFiles = await provider.GetFiles(target, cancellationToken).ConfigureAwait(false);
|
||||
var remoteIds = remoteFiles.Items.Select(i => i.FullName).ToList();
|
||||
|
||||
var jobItemIds = new List<string>();
|
||||
|
||||
foreach (var localItem in localItems)
|
||||
{
|
||||
if (remoteIds.Contains(localItem.FileId, StringComparer.OrdinalIgnoreCase))
|
||||
{
|
||||
jobItemIds.Add(localItem.SyncJobItemId);
|
||||
}
|
||||
}
|
||||
|
||||
var result = await _syncManager.SyncData(new SyncDataRequest
|
||||
{
|
||||
TargetId = target.Id,
|
||||
SyncJobItemIds = jobItemIds
|
||||
|
||||
}).ConfigureAwait(false);
|
||||
|
||||
cancellationToken.ThrowIfCancellationRequested();
|
||||
|
||||
foreach (var itemIdToRemove in result.ItemIdsToRemove)
|
||||
{
|
||||
try
|
||||
{
|
||||
await RemoveItem(provider, dataProvider, serverId, itemIdToRemove, target, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.ErrorException("Error deleting item from device. Id: {0}", ex, itemIdToRemove);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private async Task GetNewMedia(IServerSyncProvider provider,
|
||||
ISyncDataProvider dataProvider,
|
||||
SyncTarget target,
|
||||
string serverId,
|
||||
string serverName,
|
||||
IProgress<double> progress,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
var jobItems = await _syncManager.GetReadySyncItems(target.Id).ConfigureAwait(false);
|
||||
|
||||
var numComplete = 0;
|
||||
double startingPercent = 0;
|
||||
double percentPerItem = 1;
|
||||
if (jobItems.Count > 0)
|
||||
{
|
||||
percentPerItem /= jobItems.Count;
|
||||
}
|
||||
|
||||
foreach (var jobItem in jobItems)
|
||||
{
|
||||
cancellationToken.ThrowIfCancellationRequested();
|
||||
|
||||
var currentPercent = startingPercent;
|
||||
var innerProgress = new ActionableProgress<double>();
|
||||
innerProgress.RegisterAction(pct =>
|
||||
{
|
||||
var totalProgress = pct * percentPerItem;
|
||||
totalProgress += currentPercent;
|
||||
progress.Report(totalProgress);
|
||||
});
|
||||
|
||||
try
|
||||
{
|
||||
await GetItem(provider, dataProvider, target, serverId, serverName, jobItem, innerProgress, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.ErrorException("Error syncing item", ex);
|
||||
}
|
||||
|
||||
numComplete++;
|
||||
startingPercent = numComplete;
|
||||
startingPercent /= jobItems.Count;
|
||||
startingPercent *= 100;
|
||||
progress.Report(startingPercent);
|
||||
}
|
||||
}
|
||||
|
||||
private async Task GetItem(IServerSyncProvider provider,
|
||||
ISyncDataProvider dataProvider,
|
||||
SyncTarget target,
|
||||
string serverId,
|
||||
string serverName,
|
||||
SyncedItem jobItem,
|
||||
IProgress<double> progress,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
var libraryItem = jobItem.Item;
|
||||
var internalSyncJobItem = _syncManager.GetJobItem(jobItem.SyncJobItemId);
|
||||
var internalSyncJob = _syncManager.GetJob(jobItem.SyncJobId);
|
||||
|
||||
var localItem = CreateLocalItem(provider, jobItem, internalSyncJob, target, libraryItem, serverId, serverName, jobItem.OriginalFileName);
|
||||
|
||||
await _syncManager.ReportSyncJobItemTransferBeginning(internalSyncJobItem.Id);
|
||||
|
||||
var transferSuccess = false;
|
||||
Exception transferException = null;
|
||||
|
||||
var options = _config.GetSyncOptions();
|
||||
|
||||
try
|
||||
{
|
||||
var fileTransferProgress = new ActionableProgress<double>();
|
||||
fileTransferProgress.RegisterAction(pct => progress.Report(pct * .92));
|
||||
|
||||
var sendFileResult = await SendFile(provider, internalSyncJobItem.OutputPath, localItem.LocalPath.Split(PathSeparatorChar), target, options, fileTransferProgress, 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.RequiredHttpHeaders = sendFileResult.RequiredHttpHeaders;
|
||||
mediaSource.SupportsTranscoding = false;
|
||||
}
|
||||
}
|
||||
|
||||
localItem.FileId = sendFileResult.Id;
|
||||
|
||||
// Create db record
|
||||
await dataProvider.AddOrUpdate(target, localItem).ConfigureAwait(false);
|
||||
|
||||
if (localItem.Item.MediaSources != null)
|
||||
{
|
||||
var mediaSource = localItem.Item.MediaSources.FirstOrDefault();
|
||||
if (mediaSource != null)
|
||||
{
|
||||
await SendSubtitles(localItem, mediaSource, provider, dataProvider, target, options, cancellationToken).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;
|
||||
}
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
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 string GetSubtitleSaveFileName(LocalItem item, string language, bool isForced)
|
||||
{
|
||||
var path = item.LocalPath;
|
||||
|
||||
var name = Path.GetFileNameWithoutExtension(path);
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(language))
|
||||
{
|
||||
name += "." + language.ToLower();
|
||||
}
|
||||
|
||||
if (isForced)
|
||||
{
|
||||
name += ".foreign";
|
||||
}
|
||||
|
||||
return name;
|
||||
}
|
||||
|
||||
private async Task RemoveItem(IServerSyncProvider provider,
|
||||
ISyncDataProvider dataProvider,
|
||||
string serverId,
|
||||
string syncJobItemId,
|
||||
SyncTarget target,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
var localItems = await dataProvider.GetItemsBySyncJobItemId(target, serverId, syncJobItemId);
|
||||
|
||||
foreach (var localItem in localItems)
|
||||
{
|
||||
var files = localItem.AdditionalFiles.ToList();
|
||||
|
||||
foreach (var file in files)
|
||||
{
|
||||
_logger.Debug("Removing {0} from {1}.", file, target.Name);
|
||||
await provider.DeleteFile(file, target, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
_logger.Debug("Removing {0} from {1}.", localItem.FileId, target.Name);
|
||||
await provider.DeleteFile(localItem.FileId, target, cancellationToken).ConfigureAwait(false);
|
||||
|
||||
await dataProvider.Delete(target, localItem.Id).ConfigureAwait(false);
|
||||
}
|
||||
}
|
||||
|
||||
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, FileOpenMode.Open, FileAccessMode.Read, FileShareMode.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);
|
||||
}
|
||||
}
|
||||
|
||||
private static string GetLocalId(string jobItemId, string itemId)
|
||||
{
|
||||
var bytes = Encoding.UTF8.GetBytes(jobItemId + itemId);
|
||||
bytes = CreateMd5(bytes);
|
||||
return BitConverter.ToString(bytes, 0, bytes.Length).Replace("-", string.Empty);
|
||||
}
|
||||
|
||||
private static byte[] CreateMd5(byte[] value)
|
||||
{
|
||||
using (var provider = MD5.Create())
|
||||
{
|
||||
return provider.ComputeHash(value);
|
||||
}
|
||||
}
|
||||
|
||||
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 List<string> GetDirectoryPath(IServerSyncProvider provider, SyncJob job, SyncedItem syncedItem, BaseItemDto item, string serverName)
|
||||
{
|
||||
var parts = new List<string>
|
||||
{
|
||||
serverName
|
||||
};
|
||||
|
||||
var profileOption = _syncManager.GetProfileOptions(job.TargetId)
|
||||
.FirstOrDefault(i => string.Equals(i.Id, job.Profile, StringComparison.OrdinalIgnoreCase));
|
||||
|
||||
string name;
|
||||
|
||||
if (profileOption != null && !string.IsNullOrWhiteSpace(profileOption.Name))
|
||||
{
|
||||
name = profileOption.Name;
|
||||
|
||||
if (job.Bitrate.HasValue)
|
||||
{
|
||||
name += "-" + job.Bitrate.Value.ToString(CultureInfo.InvariantCulture);
|
||||
}
|
||||
else
|
||||
{
|
||||
var qualityOption = _syncManager.GetQualityOptions(job.TargetId)
|
||||
.FirstOrDefault(i => string.Equals(i.Id, job.Quality, StringComparison.OrdinalIgnoreCase));
|
||||
|
||||
if (qualityOption != null && !string.IsNullOrWhiteSpace(qualityOption.Name))
|
||||
{
|
||||
name += "-" + qualityOption.Name;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
name = syncedItem.SyncJobName + "-" + syncedItem.SyncJobDateCreated
|
||||
.ToLocalTime()
|
||||
.ToString("g")
|
||||
.Replace(" ", "-");
|
||||
}
|
||||
|
||||
name = GetValidFilename(provider, name);
|
||||
parts.Add(name);
|
||||
|
||||
if (item.IsType("episode"))
|
||||
{
|
||||
parts.Add("TV");
|
||||
if (!string.IsNullOrWhiteSpace(item.SeriesName))
|
||||
{
|
||||
parts.Add(item.SeriesName);
|
||||
}
|
||||
}
|
||||
else if (item.IsVideo)
|
||||
{
|
||||
parts.Add("Videos");
|
||||
parts.Add(item.Name);
|
||||
}
|
||||
else if (item.IsAudio)
|
||||
{
|
||||
parts.Add("Music");
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(item.AlbumArtist))
|
||||
{
|
||||
parts.Add(item.AlbumArtist);
|
||||
}
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(item.Album))
|
||||
{
|
||||
parts.Add(item.Album);
|
||||
}
|
||||
}
|
||||
else if (string.Equals(item.MediaType, MediaType.Photo, StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
parts.Add("Photos");
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(item.Album))
|
||||
{
|
||||
parts.Add(item.Album);
|
||||
}
|
||||
}
|
||||
|
||||
return parts.Select(i => GetValidFilename(provider, i)).ToList();
|
||||
}
|
||||
|
||||
private string GetLocalFileName(IServerSyncProvider provider, BaseItemDto item, string originalFileName)
|
||||
{
|
||||
var filename = originalFileName;
|
||||
|
||||
if (string.IsNullOrWhiteSpace(filename))
|
||||
{
|
||||
filename = item.Name;
|
||||
}
|
||||
|
||||
return GetValidFilename(provider, filename);
|
||||
}
|
||||
|
||||
private string GetValidFilename(IServerSyncProvider provider, string filename)
|
||||
{
|
||||
// We can always add this method to the sync provider if it's really needed
|
||||
return _fileSystem.GetValidFilename(filename);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,76 +0,0 @@
|
||||
using MediaBrowser.Common.Configuration;
|
||||
using MediaBrowser.Common.Progress;
|
||||
using MediaBrowser.Controller;
|
||||
using MediaBrowser.Controller.Sync;
|
||||
using MediaBrowser.Model.Logging;
|
||||
using MediaBrowser.Model.Sync;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using MediaBrowser.Common.IO;
|
||||
using MediaBrowser.Controller.IO;
|
||||
using MediaBrowser.Model.IO;
|
||||
|
||||
namespace MediaBrowser.Server.Implementations.Sync
|
||||
{
|
||||
public class MultiProviderSync
|
||||
{
|
||||
private readonly SyncManager _syncManager;
|
||||
private readonly IServerApplicationHost _appHost;
|
||||
private readonly ILogger _logger;
|
||||
private readonly IFileSystem _fileSystem;
|
||||
private readonly IConfigurationManager _config;
|
||||
|
||||
public MultiProviderSync(SyncManager syncManager, IServerApplicationHost appHost, ILogger logger, IFileSystem fileSystem, IConfigurationManager config)
|
||||
{
|
||||
_syncManager = syncManager;
|
||||
_appHost = appHost;
|
||||
_logger = logger;
|
||||
_fileSystem = fileSystem;
|
||||
_config = config;
|
||||
}
|
||||
|
||||
public async Task Sync(IEnumerable<IServerSyncProvider> providers, IProgress<double> progress, CancellationToken cancellationToken)
|
||||
{
|
||||
var targets = providers
|
||||
.SelectMany(i => i.GetAllSyncTargets().Select(t => new Tuple<IServerSyncProvider, SyncTarget>(i, t)))
|
||||
.ToList();
|
||||
|
||||
var numComplete = 0;
|
||||
double startingPercent = 0;
|
||||
double percentPerItem = 1;
|
||||
if (targets.Count > 0)
|
||||
{
|
||||
percentPerItem /= targets.Count;
|
||||
}
|
||||
|
||||
foreach (var target in targets)
|
||||
{
|
||||
cancellationToken.ThrowIfCancellationRequested();
|
||||
|
||||
var currentPercent = startingPercent;
|
||||
var innerProgress = new ActionableProgress<double>();
|
||||
innerProgress.RegisterAction(pct =>
|
||||
{
|
||||
var totalProgress = pct * percentPerItem;
|
||||
totalProgress += currentPercent;
|
||||
progress.Report(totalProgress);
|
||||
});
|
||||
|
||||
var dataProvider = _syncManager.GetDataProvider(target.Item1, target.Item2);
|
||||
|
||||
await new MediaSync(_logger, _syncManager, _appHost, _fileSystem, _config)
|
||||
.Sync(target.Item1, dataProvider, target.Item2, innerProgress, cancellationToken)
|
||||
.ConfigureAwait(false);
|
||||
|
||||
numComplete++;
|
||||
startingPercent = numComplete;
|
||||
startingPercent /= targets.Count;
|
||||
startingPercent *= 100;
|
||||
progress.Report(startingPercent);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,92 +0,0 @@
|
||||
using MediaBrowser.Common.Configuration;
|
||||
using MediaBrowser.Controller;
|
||||
using MediaBrowser.Controller.Sync;
|
||||
using MediaBrowser.Model.Logging;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using MediaBrowser.Model.IO;
|
||||
using MediaBrowser.Model.Tasks;
|
||||
|
||||
namespace MediaBrowser.Server.Implementations.Sync
|
||||
{
|
||||
class ServerSyncScheduledTask : IScheduledTask, IConfigurableScheduledTask
|
||||
{
|
||||
private readonly ISyncManager _syncManager;
|
||||
private readonly ILogger _logger;
|
||||
private readonly IFileSystem _fileSystem;
|
||||
private readonly IServerApplicationHost _appHost;
|
||||
private readonly IConfigurationManager _config;
|
||||
|
||||
public ServerSyncScheduledTask(ISyncManager syncManager, ILogger logger, IFileSystem fileSystem, IServerApplicationHost appHost, IConfigurationManager config)
|
||||
{
|
||||
_syncManager = syncManager;
|
||||
_logger = logger;
|
||||
_fileSystem = fileSystem;
|
||||
_appHost = appHost;
|
||||
_config = config;
|
||||
}
|
||||
|
||||
public string Name
|
||||
{
|
||||
get { return "Cloud & Folder Sync"; }
|
||||
}
|
||||
|
||||
public string Description
|
||||
{
|
||||
get { return "Sync media to the cloud"; }
|
||||
}
|
||||
|
||||
public string Category
|
||||
{
|
||||
get
|
||||
{
|
||||
return "Sync";
|
||||
}
|
||||
}
|
||||
|
||||
public Task Execute(CancellationToken cancellationToken, IProgress<double> progress)
|
||||
{
|
||||
return new MultiProviderSync((SyncManager)_syncManager, _appHost, _logger, _fileSystem, _config)
|
||||
.Sync(ServerSyncProviders, progress, cancellationToken);
|
||||
}
|
||||
|
||||
public IEnumerable<IServerSyncProvider> ServerSyncProviders
|
||||
{
|
||||
get { return ((SyncManager)_syncManager).ServerSyncProviders; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Creates the triggers that define when the task will run
|
||||
/// </summary>
|
||||
public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
|
||||
{
|
||||
return new[] {
|
||||
|
||||
// Every so often
|
||||
new TaskTriggerInfo { Type = TaskTriggerInfo.TriggerInterval, IntervalTicks = TimeSpan.FromHours(3).Ticks}
|
||||
};
|
||||
}
|
||||
public bool IsHidden
|
||||
{
|
||||
get { return !IsEnabled; }
|
||||
}
|
||||
|
||||
public bool IsEnabled
|
||||
{
|
||||
get { return ServerSyncProviders.Any(); }
|
||||
}
|
||||
|
||||
public bool IsLogged
|
||||
{
|
||||
get { return true; }
|
||||
}
|
||||
|
||||
public string Key
|
||||
{
|
||||
get { return "ServerSync"; }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
using MediaBrowser.Common.Configuration;
|
||||
using MediaBrowser.Model.Sync;
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace MediaBrowser.Server.Implementations.Sync
|
||||
{
|
||||
public class SyncConfigurationFactory : IConfigurationFactory
|
||||
{
|
||||
public IEnumerable<ConfigurationStore> GetConfigurations()
|
||||
{
|
||||
return new List<ConfigurationStore>
|
||||
{
|
||||
new ConfigurationStore
|
||||
{
|
||||
ConfigurationType = typeof(SyncOptions),
|
||||
Key = "sync"
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
public static class SyncExtensions
|
||||
{
|
||||
public static SyncOptions GetSyncOptions(this IConfigurationManager config)
|
||||
{
|
||||
return config.GetConfiguration<SyncOptions>("sync");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,89 +0,0 @@
|
||||
using MediaBrowser.Common.Configuration;
|
||||
using MediaBrowser.Controller.Library;
|
||||
using MediaBrowser.Controller.MediaEncoding;
|
||||
using MediaBrowser.Controller.Sync;
|
||||
using MediaBrowser.Controller.TV;
|
||||
using MediaBrowser.Model.Logging;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using MediaBrowser.Common.IO;
|
||||
using MediaBrowser.Controller.IO;
|
||||
using MediaBrowser.Model.IO;
|
||||
using MediaBrowser.Model.Tasks;
|
||||
|
||||
namespace MediaBrowser.Server.Implementations.Sync
|
||||
{
|
||||
public class SyncConvertScheduledTask : IScheduledTask
|
||||
{
|
||||
private readonly ILibraryManager _libraryManager;
|
||||
private readonly ISyncRepository _syncRepo;
|
||||
private readonly ISyncManager _syncManager;
|
||||
private readonly ILogger _logger;
|
||||
private readonly IUserManager _userManager;
|
||||
private readonly ITVSeriesManager _tvSeriesManager;
|
||||
private readonly IMediaEncoder _mediaEncoder;
|
||||
private readonly ISubtitleEncoder _subtitleEncoder;
|
||||
private readonly IConfigurationManager _config;
|
||||
private readonly IFileSystem _fileSystem;
|
||||
private readonly IMediaSourceManager _mediaSourceManager;
|
||||
|
||||
public SyncConvertScheduledTask(ILibraryManager libraryManager, ISyncRepository syncRepo, ISyncManager syncManager, ILogger logger, IUserManager userManager, ITVSeriesManager tvSeriesManager, IMediaEncoder mediaEncoder, ISubtitleEncoder subtitleEncoder, IConfigurationManager config, IFileSystem fileSystem, IMediaSourceManager mediaSourceManager)
|
||||
{
|
||||
_libraryManager = libraryManager;
|
||||
_syncRepo = syncRepo;
|
||||
_syncManager = syncManager;
|
||||
_logger = logger;
|
||||
_userManager = userManager;
|
||||
_tvSeriesManager = tvSeriesManager;
|
||||
_mediaEncoder = mediaEncoder;
|
||||
_subtitleEncoder = subtitleEncoder;
|
||||
_config = config;
|
||||
_fileSystem = fileSystem;
|
||||
_mediaSourceManager = mediaSourceManager;
|
||||
}
|
||||
|
||||
public string Name
|
||||
{
|
||||
get { return "Convert media"; }
|
||||
}
|
||||
|
||||
public string Description
|
||||
{
|
||||
get { return "Runs scheduled sync jobs"; }
|
||||
}
|
||||
|
||||
public string Category
|
||||
{
|
||||
get
|
||||
{
|
||||
return "Sync";
|
||||
}
|
||||
}
|
||||
|
||||
public Task Execute(CancellationToken cancellationToken, IProgress<double> progress)
|
||||
{
|
||||
return new SyncJobProcessor(_libraryManager, _syncRepo, (SyncManager)_syncManager, _logger, _userManager, _tvSeriesManager, _mediaEncoder, _subtitleEncoder, _config, _fileSystem, _mediaSourceManager)
|
||||
.Sync(progress, cancellationToken);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Creates the triggers that define when the task will run
|
||||
/// </summary>
|
||||
/// <returns>IEnumerable{BaseTaskTrigger}.</returns>
|
||||
public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
|
||||
{
|
||||
return new[] {
|
||||
|
||||
// Every so often
|
||||
new TaskTriggerInfo { Type = TaskTriggerInfo.TriggerInterval, IntervalTicks = TimeSpan.FromHours(3).Ticks}
|
||||
};
|
||||
}
|
||||
|
||||
public string Key
|
||||
{
|
||||
get { return "SyncPrepare"; }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
using System;
|
||||
|
||||
namespace MediaBrowser.Server.Implementations.Sync
|
||||
{
|
||||
public class SyncHelper
|
||||
{
|
||||
public static int? AdjustBitrate(int? profileBitrate, string quality)
|
||||
{
|
||||
if (profileBitrate.HasValue)
|
||||
{
|
||||
if (string.Equals(quality, "medium", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
profileBitrate = Math.Min(profileBitrate.Value, 4000000);
|
||||
}
|
||||
else if (string.Equals(quality, "low", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
profileBitrate = Math.Min(profileBitrate.Value, 1500000);
|
||||
}
|
||||
}
|
||||
|
||||
return profileBitrate;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,18 +0,0 @@
|
||||
using MediaBrowser.Model.Dlna;
|
||||
|
||||
namespace MediaBrowser.Server.Implementations.Sync
|
||||
{
|
||||
public class SyncJobOptions
|
||||
{
|
||||
/// <summary>
|
||||
/// Gets or sets the conversion options.
|
||||
/// </summary>
|
||||
/// <value>The conversion options.</value>
|
||||
public DeviceProfile DeviceProfile { get; set; }
|
||||
/// <summary>
|
||||
/// Gets or sets a value indicating whether this instance is converting.
|
||||
/// </summary>
|
||||
/// <value><c>true</c> if this instance is converting; otherwise, <c>false</c>.</value>
|
||||
public bool IsConverting { get; set; }
|
||||
}
|
||||
}
|
||||
@@ -1,988 +0,0 @@
|
||||
using MediaBrowser.Common.Configuration;
|
||||
using MediaBrowser.Common.IO;
|
||||
using MediaBrowser.Common.Progress;
|
||||
using MediaBrowser.Controller.Entities;
|
||||
using MediaBrowser.Controller.Entities.Audio;
|
||||
using MediaBrowser.Controller.Entities.TV;
|
||||
using MediaBrowser.Controller.Library;
|
||||
using MediaBrowser.Controller.MediaEncoding;
|
||||
using MediaBrowser.Controller.Sync;
|
||||
using MediaBrowser.Controller.TV;
|
||||
using MediaBrowser.Model.Dlna;
|
||||
using MediaBrowser.Model.Dto;
|
||||
using MediaBrowser.Model.Entities;
|
||||
using MediaBrowser.Model.Logging;
|
||||
using MediaBrowser.Model.MediaInfo;
|
||||
using MediaBrowser.Model.Querying;
|
||||
using MediaBrowser.Model.Session;
|
||||
using MediaBrowser.Model.Sync;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Globalization;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using MediaBrowser.Controller.IO;
|
||||
using MediaBrowser.Model.IO;
|
||||
using MediaBrowser.Model.Extensions;
|
||||
using MediaBrowser.Model.IO;
|
||||
|
||||
namespace MediaBrowser.Server.Implementations.Sync
|
||||
{
|
||||
public class SyncJobProcessor
|
||||
{
|
||||
private readonly ILibraryManager _libraryManager;
|
||||
private readonly ISyncRepository _syncRepo;
|
||||
private readonly SyncManager _syncManager;
|
||||
private readonly ILogger _logger;
|
||||
private readonly IUserManager _userManager;
|
||||
private readonly ITVSeriesManager _tvSeriesManager;
|
||||
private readonly IMediaEncoder _mediaEncoder;
|
||||
private readonly ISubtitleEncoder _subtitleEncoder;
|
||||
private readonly IConfigurationManager _config;
|
||||
private readonly IFileSystem _fileSystem;
|
||||
private readonly IMediaSourceManager _mediaSourceManager;
|
||||
|
||||
public SyncJobProcessor(ILibraryManager libraryManager, ISyncRepository syncRepo, SyncManager syncManager, ILogger logger, IUserManager userManager, ITVSeriesManager tvSeriesManager, IMediaEncoder mediaEncoder, ISubtitleEncoder subtitleEncoder, IConfigurationManager config, IFileSystem fileSystem, IMediaSourceManager mediaSourceManager)
|
||||
{
|
||||
_libraryManager = libraryManager;
|
||||
_syncRepo = syncRepo;
|
||||
_syncManager = syncManager;
|
||||
_logger = logger;
|
||||
_userManager = userManager;
|
||||
_tvSeriesManager = tvSeriesManager;
|
||||
_mediaEncoder = mediaEncoder;
|
||||
_subtitleEncoder = subtitleEncoder;
|
||||
_config = config;
|
||||
_fileSystem = fileSystem;
|
||||
_mediaSourceManager = mediaSourceManager;
|
||||
}
|
||||
|
||||
public async Task EnsureJobItems(SyncJob job)
|
||||
{
|
||||
var user = _userManager.GetUserById(job.UserId);
|
||||
|
||||
if (user == null)
|
||||
{
|
||||
throw new InvalidOperationException("Cannot proceed with sync because user no longer exists.");
|
||||
}
|
||||
|
||||
var items = (await GetItemsForSync(job.Category, job.ParentId, job.RequestedItemIds, user, job.UnwatchedOnly).ConfigureAwait(false))
|
||||
.ToList();
|
||||
|
||||
var jobItems = _syncManager.GetJobItems(new SyncJobItemQuery
|
||||
{
|
||||
JobId = job.Id,
|
||||
AddMetadata = false
|
||||
|
||||
}).Items.ToList();
|
||||
|
||||
foreach (var item in items)
|
||||
{
|
||||
// Respect ItemLimit, if set
|
||||
if (job.ItemLimit.HasValue)
|
||||
{
|
||||
if (jobItems.Count(j => j.Status != SyncJobItemStatus.RemovedFromDevice && j.Status != SyncJobItemStatus.Failed) >= job.ItemLimit.Value)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
var itemId = item.Id.ToString("N");
|
||||
|
||||
var jobItem = jobItems.FirstOrDefault(i => string.Equals(i.ItemId, itemId, StringComparison.OrdinalIgnoreCase));
|
||||
|
||||
if (jobItem != null)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
var index = jobItems.Count == 0 ?
|
||||
0 :
|
||||
jobItems.Select(i => i.JobItemIndex).Max() + 1;
|
||||
|
||||
jobItem = new SyncJobItem
|
||||
{
|
||||
Id = Guid.NewGuid().ToString("N"),
|
||||
ItemId = itemId,
|
||||
ItemName = GetSyncJobItemName(item),
|
||||
JobId = job.Id,
|
||||
TargetId = job.TargetId,
|
||||
DateCreated = DateTime.UtcNow,
|
||||
JobItemIndex = index
|
||||
};
|
||||
|
||||
await _syncRepo.Create(jobItem).ConfigureAwait(false);
|
||||
_syncManager.OnSyncJobItemCreated(jobItem);
|
||||
|
||||
jobItems.Add(jobItem);
|
||||
}
|
||||
|
||||
jobItems = jobItems
|
||||
.OrderBy(i => i.DateCreated)
|
||||
.ToList();
|
||||
|
||||
await UpdateJobStatus(job, jobItems).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private string GetSyncJobItemName(BaseItem item)
|
||||
{
|
||||
var name = item.Name;
|
||||
var episode = item as Episode;
|
||||
|
||||
if (episode != null)
|
||||
{
|
||||
if (episode.IndexNumber.HasValue)
|
||||
{
|
||||
name = "E" + episode.IndexNumber.Value.ToString(CultureInfo.InvariantCulture) + " - " + name;
|
||||
}
|
||||
|
||||
if (episode.ParentIndexNumber.HasValue)
|
||||
{
|
||||
name = "S" + episode.ParentIndexNumber.Value.ToString(CultureInfo.InvariantCulture) + ", " + name;
|
||||
}
|
||||
}
|
||||
|
||||
return name;
|
||||
}
|
||||
|
||||
public Task UpdateJobStatus(string id)
|
||||
{
|
||||
var job = _syncRepo.GetJob(id);
|
||||
|
||||
if (job == null)
|
||||
{
|
||||
return Task.FromResult(true);
|
||||
}
|
||||
|
||||
var result = _syncManager.GetJobItems(new SyncJobItemQuery
|
||||
{
|
||||
JobId = job.Id,
|
||||
AddMetadata = false
|
||||
});
|
||||
|
||||
return UpdateJobStatus(job, result.Items.ToList());
|
||||
}
|
||||
|
||||
private async Task UpdateJobStatus(SyncJob job, List<SyncJobItem> jobItems)
|
||||
{
|
||||
job.ItemCount = jobItems.Count;
|
||||
|
||||
double pct = 0;
|
||||
|
||||
foreach (var item in jobItems)
|
||||
{
|
||||
if (item.Status == SyncJobItemStatus.Failed || item.Status == SyncJobItemStatus.Synced || item.Status == SyncJobItemStatus.RemovedFromDevice || item.Status == SyncJobItemStatus.Cancelled)
|
||||
{
|
||||
pct += 100;
|
||||
}
|
||||
else
|
||||
{
|
||||
pct += item.Progress ?? 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (job.ItemCount > 0)
|
||||
{
|
||||
pct /= job.ItemCount;
|
||||
job.Progress = pct;
|
||||
}
|
||||
else
|
||||
{
|
||||
job.Progress = null;
|
||||
}
|
||||
|
||||
if (jobItems.Any(i => i.Status == SyncJobItemStatus.Transferring))
|
||||
{
|
||||
job.Status = SyncJobStatus.Transferring;
|
||||
}
|
||||
else if (jobItems.Any(i => i.Status == SyncJobItemStatus.Converting))
|
||||
{
|
||||
job.Status = SyncJobStatus.Converting;
|
||||
}
|
||||
else if (jobItems.All(i => i.Status == SyncJobItemStatus.Failed))
|
||||
{
|
||||
job.Status = SyncJobStatus.Failed;
|
||||
}
|
||||
else if (jobItems.All(i => i.Status == SyncJobItemStatus.Cancelled))
|
||||
{
|
||||
job.Status = SyncJobStatus.Cancelled;
|
||||
}
|
||||
else if (jobItems.All(i => i.Status == SyncJobItemStatus.ReadyToTransfer))
|
||||
{
|
||||
job.Status = SyncJobStatus.ReadyToTransfer;
|
||||
}
|
||||
else if (jobItems.All(i => i.Status == SyncJobItemStatus.Cancelled || i.Status == SyncJobItemStatus.Failed || i.Status == SyncJobItemStatus.Synced || i.Status == SyncJobItemStatus.RemovedFromDevice))
|
||||
{
|
||||
if (jobItems.Any(i => i.Status == SyncJobItemStatus.Failed))
|
||||
{
|
||||
job.Status = SyncJobStatus.CompletedWithError;
|
||||
}
|
||||
else
|
||||
{
|
||||
job.Status = SyncJobStatus.Completed;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
job.Status = SyncJobStatus.Queued;
|
||||
}
|
||||
|
||||
await _syncRepo.Update(job).ConfigureAwait(false);
|
||||
|
||||
_syncManager.OnSyncJobUpdated(job);
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<BaseItem>> GetItemsForSync(SyncCategory? category, string parentId, IEnumerable<string> itemIds, User user, bool unwatchedOnly)
|
||||
{
|
||||
var list = new List<BaseItem>();
|
||||
|
||||
if (category.HasValue)
|
||||
{
|
||||
list = (await GetItemsForSync(category.Value, parentId, user).ConfigureAwait(false)).ToList();
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (var itemId in itemIds)
|
||||
{
|
||||
var subList = await GetItemsForSync(itemId, user).ConfigureAwait(false);
|
||||
list.AddRange(subList);
|
||||
}
|
||||
}
|
||||
|
||||
IEnumerable<BaseItem> items = list;
|
||||
items = items.Where(_syncManager.SupportsSync);
|
||||
|
||||
if (unwatchedOnly)
|
||||
{
|
||||
// Avoid implicitly captured closure
|
||||
var currentUser = user;
|
||||
|
||||
items = items.Where(i =>
|
||||
{
|
||||
var video = i as Video;
|
||||
|
||||
if (video != null)
|
||||
{
|
||||
return !video.IsPlayed(currentUser);
|
||||
}
|
||||
|
||||
return true;
|
||||
});
|
||||
}
|
||||
|
||||
return items.DistinctBy(i => i.Id);
|
||||
}
|
||||
|
||||
private async Task<IEnumerable<BaseItem>> GetItemsForSync(SyncCategory category, string parentId, User user)
|
||||
{
|
||||
var parent = string.IsNullOrWhiteSpace(parentId)
|
||||
? user.RootFolder
|
||||
: (Folder)_libraryManager.GetItemById(parentId);
|
||||
|
||||
InternalItemsQuery query;
|
||||
|
||||
switch (category)
|
||||
{
|
||||
case SyncCategory.Latest:
|
||||
query = new InternalItemsQuery
|
||||
{
|
||||
IsFolder = false,
|
||||
SortBy = new[] { ItemSortBy.DateCreated, ItemSortBy.SortName },
|
||||
SortOrder = SortOrder.Descending,
|
||||
Recursive = true
|
||||
};
|
||||
break;
|
||||
case SyncCategory.Resume:
|
||||
query = new InternalItemsQuery
|
||||
{
|
||||
IsFolder = false,
|
||||
SortBy = new[] { ItemSortBy.DatePlayed, ItemSortBy.SortName },
|
||||
SortOrder = SortOrder.Descending,
|
||||
Recursive = true,
|
||||
IsResumable = true,
|
||||
MediaTypes = new[] { MediaType.Video }
|
||||
};
|
||||
break;
|
||||
|
||||
case SyncCategory.NextUp:
|
||||
return _tvSeriesManager.GetNextUp(new NextUpQuery
|
||||
{
|
||||
ParentId = parentId,
|
||||
UserId = user.Id.ToString("N")
|
||||
}).Items;
|
||||
|
||||
default:
|
||||
throw new ArgumentException("Unrecognized category: " + category);
|
||||
}
|
||||
|
||||
if (parent == null)
|
||||
{
|
||||
return new List<BaseItem>();
|
||||
}
|
||||
|
||||
query.User = user;
|
||||
|
||||
var result = await parent.GetItems(query).ConfigureAwait(false);
|
||||
return result.Items;
|
||||
}
|
||||
|
||||
private async Task<List<BaseItem>> GetItemsForSync(string id, User user)
|
||||
{
|
||||
var item = _libraryManager.GetItemById(id);
|
||||
|
||||
if (item == null)
|
||||
{
|
||||
return new List<BaseItem>();
|
||||
}
|
||||
|
||||
var itemByName = item as IItemByName;
|
||||
if (itemByName != null)
|
||||
{
|
||||
return itemByName.GetTaggedItems(new InternalItemsQuery(user)
|
||||
{
|
||||
IsFolder = false,
|
||||
Recursive = true
|
||||
}).ToList();
|
||||
}
|
||||
|
||||
if (item.IsFolder)
|
||||
{
|
||||
var folder = (Folder)item;
|
||||
var itemsResult = await folder.GetItems(new InternalItemsQuery(user)
|
||||
{
|
||||
Recursive = true,
|
||||
IsFolder = false
|
||||
|
||||
}).ConfigureAwait(false);
|
||||
|
||||
var items = itemsResult.Items;
|
||||
|
||||
if (!folder.IsPreSorted)
|
||||
{
|
||||
items = _libraryManager.Sort(items, user, new[] { ItemSortBy.SortName }, SortOrder.Ascending)
|
||||
.ToArray();
|
||||
}
|
||||
|
||||
return items.ToList();
|
||||
}
|
||||
|
||||
return new List<BaseItem> { item };
|
||||
}
|
||||
|
||||
private async Task EnsureSyncJobItems(string targetId, CancellationToken cancellationToken)
|
||||
{
|
||||
var jobResult = _syncRepo.GetJobs(new SyncJobQuery
|
||||
{
|
||||
SyncNewContent = true,
|
||||
TargetId = targetId
|
||||
});
|
||||
|
||||
foreach (var job in jobResult.Items)
|
||||
{
|
||||
cancellationToken.ThrowIfCancellationRequested();
|
||||
|
||||
if (job.SyncNewContent)
|
||||
{
|
||||
await EnsureJobItems(job).ConfigureAwait(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public async Task Sync(IProgress<double> progress, CancellationToken cancellationToken)
|
||||
{
|
||||
await EnsureSyncJobItems(null, cancellationToken).ConfigureAwait(false);
|
||||
|
||||
// Look job items that are supposedly transfering, but need to be requeued because the synced files have been deleted somehow
|
||||
await HandleDeletedSyncFiles(cancellationToken).ConfigureAwait(false);
|
||||
|
||||
// If it already has a converting status then is must have been aborted during conversion
|
||||
var result = _syncManager.GetJobItems(new SyncJobItemQuery
|
||||
{
|
||||
Statuses = new[] { SyncJobItemStatus.Queued, SyncJobItemStatus.Converting },
|
||||
AddMetadata = false
|
||||
});
|
||||
|
||||
await SyncJobItems(result.Items, true, progress, cancellationToken).ConfigureAwait(false);
|
||||
|
||||
CleanDeadSyncFiles();
|
||||
}
|
||||
|
||||
private async Task HandleDeletedSyncFiles(CancellationToken cancellationToken)
|
||||
{
|
||||
// Look job items that are supposedly transfering, but need to be requeued because the synced files have been deleted somehow
|
||||
var result = _syncManager.GetJobItems(new SyncJobItemQuery
|
||||
{
|
||||
Statuses = new[] { SyncJobItemStatus.ReadyToTransfer, SyncJobItemStatus.Transferring },
|
||||
AddMetadata = false
|
||||
});
|
||||
|
||||
foreach (var item in result.Items)
|
||||
{
|
||||
cancellationToken.ThrowIfCancellationRequested();
|
||||
|
||||
if (string.IsNullOrWhiteSpace(item.OutputPath) || !_fileSystem.FileExists(item.OutputPath))
|
||||
{
|
||||
item.Status = SyncJobItemStatus.Queued;
|
||||
await _syncManager.UpdateSyncJobItemInternal(item).ConfigureAwait(false);
|
||||
await UpdateJobStatus(item.JobId).ConfigureAwait(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void CleanDeadSyncFiles()
|
||||
{
|
||||
// TODO
|
||||
// Clean files in sync temp folder that are not linked to any sync jobs
|
||||
}
|
||||
|
||||
public async Task SyncJobItems(string targetId, bool enableConversion, IProgress<double> progress,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
await EnsureSyncJobItems(targetId, cancellationToken).ConfigureAwait(false);
|
||||
|
||||
// If it already has a converting status then is must have been aborted during conversion
|
||||
var result = _syncManager.GetJobItems(new SyncJobItemQuery
|
||||
{
|
||||
Statuses = new[] { SyncJobItemStatus.Queued, SyncJobItemStatus.Converting },
|
||||
TargetId = targetId,
|
||||
AddMetadata = false
|
||||
});
|
||||
|
||||
await SyncJobItems(result.Items, enableConversion, progress, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
public async Task SyncJobItems(SyncJobItem[] items, bool enableConversion, IProgress<double> progress, CancellationToken cancellationToken)
|
||||
{
|
||||
if (items.Length > 0)
|
||||
{
|
||||
if (!SyncRegistrationInfo.Instance.IsRegistered)
|
||||
{
|
||||
_logger.Debug("Cancelling sync job processing. Please obtain a supporter membership.");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
var numComplete = 0;
|
||||
|
||||
foreach (var item in items)
|
||||
{
|
||||
cancellationToken.ThrowIfCancellationRequested();
|
||||
|
||||
double percentPerItem = 1;
|
||||
percentPerItem /= items.Length;
|
||||
var startingPercent = numComplete * percentPerItem * 100;
|
||||
|
||||
var innerProgress = new ActionableProgress<double>();
|
||||
innerProgress.RegisterAction(p => progress.Report(startingPercent + percentPerItem * p));
|
||||
|
||||
// Pull it fresh from the db just to make sure it wasn't deleted or cancelled while another item was converting
|
||||
var jobItem = enableConversion ? _syncRepo.GetJobItem(item.Id) : item;
|
||||
|
||||
if (jobItem != null)
|
||||
{
|
||||
if (jobItem.Status != SyncJobItemStatus.Cancelled)
|
||||
{
|
||||
await ProcessJobItem(jobItem, enableConversion, innerProgress, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
await UpdateJobStatus(jobItem.JobId).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
numComplete++;
|
||||
double percent = numComplete;
|
||||
percent /= items.Length;
|
||||
progress.Report(100 * percent);
|
||||
}
|
||||
}
|
||||
|
||||
private async Task ProcessJobItem(SyncJobItem jobItem, bool enableConversion, IProgress<double> progress, CancellationToken cancellationToken)
|
||||
{
|
||||
if (jobItem == null)
|
||||
{
|
||||
throw new ArgumentNullException("jobItem");
|
||||
}
|
||||
|
||||
var item = _libraryManager.GetItemById(jobItem.ItemId);
|
||||
if (item == null)
|
||||
{
|
||||
jobItem.Status = SyncJobItemStatus.Failed;
|
||||
_logger.Error("Unable to locate library item for JobItem {0}, ItemId {1}", jobItem.Id, jobItem.ItemId);
|
||||
await _syncManager.UpdateSyncJobItemInternal(jobItem).ConfigureAwait(false);
|
||||
return;
|
||||
}
|
||||
|
||||
jobItem.Progress = 0;
|
||||
|
||||
var syncOptions = _config.GetSyncOptions();
|
||||
var job = _syncManager.GetJob(jobItem.JobId);
|
||||
var user = _userManager.GetUserById(job.UserId);
|
||||
if (user == null)
|
||||
{
|
||||
jobItem.Status = SyncJobItemStatus.Failed;
|
||||
_logger.Error("User not found. Cannot complete the sync job.");
|
||||
await _syncManager.UpdateSyncJobItemInternal(jobItem).ConfigureAwait(false);
|
||||
return;
|
||||
}
|
||||
|
||||
// See if there's already another active job item for the same target
|
||||
var existingJobItems = _syncManager.GetJobItems(new SyncJobItemQuery
|
||||
{
|
||||
AddMetadata = false,
|
||||
ItemId = jobItem.ItemId,
|
||||
TargetId = jobItem.TargetId,
|
||||
Statuses = new[] { SyncJobItemStatus.Converting, SyncJobItemStatus.Queued, SyncJobItemStatus.ReadyToTransfer, SyncJobItemStatus.Synced, SyncJobItemStatus.Transferring }
|
||||
});
|
||||
|
||||
var duplicateJobItems = existingJobItems.Items
|
||||
.Where(i => !string.Equals(i.Id, jobItem.Id, StringComparison.OrdinalIgnoreCase))
|
||||
.ToList();
|
||||
|
||||
if (duplicateJobItems.Count > 0)
|
||||
{
|
||||
var syncProvider = _syncManager.GetSyncProvider(jobItem) as IHasDuplicateCheck;
|
||||
|
||||
if (!duplicateJobItems.Any(i => AllowDuplicateJobItem(syncProvider, i, jobItem)))
|
||||
{
|
||||
_logger.Debug("Cancelling sync job item because there is already another active job for the same target.");
|
||||
jobItem.Status = SyncJobItemStatus.Cancelled;
|
||||
await _syncManager.UpdateSyncJobItemInternal(jobItem).ConfigureAwait(false);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
var video = item as Video;
|
||||
if (video != null)
|
||||
{
|
||||
await Sync(jobItem, video, user, enableConversion, syncOptions, progress, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
else if (item is Audio)
|
||||
{
|
||||
await Sync(jobItem, (Audio)item, user, enableConversion, syncOptions, progress, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
else if (item is Photo)
|
||||
{
|
||||
await Sync(jobItem, (Photo)item, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
await SyncGeneric(jobItem, item, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
}
|
||||
|
||||
private bool AllowDuplicateJobItem(IHasDuplicateCheck provider, SyncJobItem original, SyncJobItem duplicate)
|
||||
{
|
||||
if (provider != null)
|
||||
{
|
||||
return provider.AllowDuplicateJobItem(original, duplicate);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
private async Task Sync(SyncJobItem jobItem, Video item, User user, bool enableConversion, SyncOptions syncOptions, IProgress<double> progress, CancellationToken cancellationToken)
|
||||
{
|
||||
var job = _syncManager.GetJob(jobItem.JobId);
|
||||
var jobOptions = _syncManager.GetVideoOptions(jobItem, job);
|
||||
var conversionOptions = new VideoOptions
|
||||
{
|
||||
Profile = jobOptions.DeviceProfile
|
||||
};
|
||||
|
||||
conversionOptions.DeviceId = jobItem.TargetId;
|
||||
conversionOptions.Context = EncodingContext.Static;
|
||||
conversionOptions.ItemId = item.Id.ToString("N");
|
||||
conversionOptions.MediaSources = _mediaSourceManager.GetStaticMediaSources(item, false, user).ToList();
|
||||
|
||||
var streamInfo = new StreamBuilder(_mediaEncoder, _logger).BuildVideoItem(conversionOptions);
|
||||
var mediaSource = streamInfo.MediaSource;
|
||||
|
||||
// No sense creating external subs if we're already burning one into the video
|
||||
var externalSubs = streamInfo.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode ?
|
||||
new List<SubtitleStreamInfo>() :
|
||||
streamInfo.GetExternalSubtitles(false, true, null, null);
|
||||
|
||||
// Mark as requiring conversion if transcoding the video, or if any subtitles need to be extracted
|
||||
var requiresVideoTranscoding = streamInfo.PlayMethod == PlayMethod.Transcode && jobOptions.IsConverting;
|
||||
var requiresConversion = requiresVideoTranscoding || externalSubs.Any(i => RequiresExtraction(i, mediaSource));
|
||||
|
||||
if (requiresConversion && !enableConversion)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
jobItem.MediaSourceId = streamInfo.MediaSourceId;
|
||||
jobItem.TemporaryPath = GetTemporaryPath(jobItem);
|
||||
|
||||
if (requiresConversion)
|
||||
{
|
||||
jobItem.Status = SyncJobItemStatus.Converting;
|
||||
}
|
||||
|
||||
if (requiresVideoTranscoding)
|
||||
{
|
||||
// Save the job item now since conversion could take a while
|
||||
await _syncManager.UpdateSyncJobItemInternal(jobItem).ConfigureAwait(false);
|
||||
await UpdateJobStatus(jobItem.JobId).ConfigureAwait(false);
|
||||
|
||||
try
|
||||
{
|
||||
var lastJobUpdate = DateTime.MinValue;
|
||||
var innerProgress = new ActionableProgress<double>();
|
||||
innerProgress.RegisterAction(async pct =>
|
||||
{
|
||||
progress.Report(pct);
|
||||
|
||||
if ((DateTime.UtcNow - lastJobUpdate).TotalSeconds >= DatabaseProgressUpdateIntervalSeconds)
|
||||
{
|
||||
jobItem.Progress = pct / 2;
|
||||
await _syncManager.UpdateSyncJobItemInternal(jobItem).ConfigureAwait(false);
|
||||
await UpdateJobStatus(jobItem.JobId).ConfigureAwait(false);
|
||||
}
|
||||
});
|
||||
|
||||
jobItem.OutputPath = await _mediaEncoder.EncodeVideo(new EncodingJobOptions(streamInfo, conversionOptions.Profile)
|
||||
{
|
||||
OutputDirectory = jobItem.TemporaryPath,
|
||||
CpuCoreLimit = syncOptions.TranscodingCpuCoreLimit,
|
||||
ReadInputAtNativeFramerate = !syncOptions.EnableFullSpeedTranscoding
|
||||
|
||||
}, innerProgress, cancellationToken);
|
||||
|
||||
jobItem.ItemDateModifiedTicks = item.DateModified.Ticks;
|
||||
_syncManager.OnConversionComplete(jobItem);
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
jobItem.Status = SyncJobItemStatus.Queued;
|
||||
jobItem.Progress = 0;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
jobItem.Status = SyncJobItemStatus.Failed;
|
||||
_logger.ErrorException("Error during sync transcoding", ex);
|
||||
}
|
||||
|
||||
if (jobItem.Status == SyncJobItemStatus.Failed || jobItem.Status == SyncJobItemStatus.Queued)
|
||||
{
|
||||
await _syncManager.UpdateSyncJobItemInternal(jobItem).ConfigureAwait(false);
|
||||
return;
|
||||
}
|
||||
|
||||
jobItem.MediaSource = await GetEncodedMediaSource(jobItem.OutputPath, user, true).ConfigureAwait(false);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (mediaSource.Protocol == MediaProtocol.File)
|
||||
{
|
||||
jobItem.OutputPath = mediaSource.Path;
|
||||
}
|
||||
else if (mediaSource.Protocol == MediaProtocol.Http)
|
||||
{
|
||||
jobItem.OutputPath = await DownloadFile(jobItem, mediaSource, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new InvalidOperationException(string.Format("Cannot direct stream {0} protocol", mediaSource.Protocol));
|
||||
}
|
||||
|
||||
jobItem.ItemDateModifiedTicks = item.DateModified.Ticks;
|
||||
jobItem.MediaSource = mediaSource;
|
||||
}
|
||||
|
||||
jobItem.MediaSource.SupportsTranscoding = false;
|
||||
|
||||
if (externalSubs.Count > 0)
|
||||
{
|
||||
// Save the job item now since conversion could take a while
|
||||
await _syncManager.UpdateSyncJobItemInternal(jobItem).ConfigureAwait(false);
|
||||
|
||||
await ConvertSubtitles(jobItem, externalSubs, streamInfo, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
jobItem.Progress = 50;
|
||||
jobItem.Status = SyncJobItemStatus.ReadyToTransfer;
|
||||
await _syncManager.UpdateSyncJobItemInternal(jobItem).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private bool RequiresExtraction(SubtitleStreamInfo stream, MediaSourceInfo mediaSource)
|
||||
{
|
||||
var originalStream = mediaSource.MediaStreams.FirstOrDefault(i => i.Type == MediaStreamType.Subtitle && i.Index == stream.Index);
|
||||
|
||||
return originalStream != null && !originalStream.IsExternal;
|
||||
}
|
||||
|
||||
private async Task ConvertSubtitles(SyncJobItem jobItem,
|
||||
IEnumerable<SubtitleStreamInfo> subtitles,
|
||||
StreamInfo streamInfo,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
var files = new List<ItemFileInfo>();
|
||||
|
||||
var mediaStreams = jobItem.MediaSource.MediaStreams
|
||||
.Where(i => i.Type != MediaStreamType.Subtitle || !i.IsExternal)
|
||||
.ToList();
|
||||
|
||||
var startingIndex = mediaStreams.Count == 0 ?
|
||||
0 :
|
||||
mediaStreams.Select(i => i.Index).Max() + 1;
|
||||
|
||||
foreach (var subtitle in subtitles)
|
||||
{
|
||||
var fileInfo = await ConvertSubtitles(jobItem.TemporaryPath, streamInfo, subtitle, cancellationToken).ConfigureAwait(false);
|
||||
|
||||
// Reset this to a value that will be based on the output media
|
||||
fileInfo.Index = startingIndex;
|
||||
files.Add(fileInfo);
|
||||
|
||||
mediaStreams.Add(new MediaStream
|
||||
{
|
||||
Index = startingIndex,
|
||||
Codec = subtitle.Format,
|
||||
IsForced = subtitle.IsForced,
|
||||
IsExternal = true,
|
||||
Language = subtitle.Language,
|
||||
Path = fileInfo.Path,
|
||||
SupportsExternalStream = true,
|
||||
Type = MediaStreamType.Subtitle
|
||||
});
|
||||
|
||||
startingIndex++;
|
||||
}
|
||||
|
||||
jobItem.AdditionalFiles.AddRange(files);
|
||||
|
||||
jobItem.MediaSource.MediaStreams = mediaStreams;
|
||||
}
|
||||
|
||||
private async Task<ItemFileInfo> ConvertSubtitles(string temporaryPath, StreamInfo streamInfo, SubtitleStreamInfo subtitleStreamInfo, CancellationToken cancellationToken)
|
||||
{
|
||||
var subtitleStreamIndex = subtitleStreamInfo.Index;
|
||||
|
||||
var filename = Guid.NewGuid() + "." + subtitleStreamInfo.Format.ToLower();
|
||||
|
||||
var path = Path.Combine(temporaryPath, filename);
|
||||
|
||||
_fileSystem.CreateDirectory(Path.GetDirectoryName(path));
|
||||
|
||||
using (var stream = await _subtitleEncoder.GetSubtitles(streamInfo.ItemId, streamInfo.MediaSourceId, subtitleStreamIndex, subtitleStreamInfo.Format, 0, null, false, cancellationToken).ConfigureAwait(false))
|
||||
{
|
||||
using (var fs = _fileSystem.GetFileStream(path, FileOpenMode.Create, FileAccessMode.Write, FileShareMode.Read, true))
|
||||
{
|
||||
await stream.CopyToAsync(fs, StreamDefaults.DefaultCopyToBufferSize, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
}
|
||||
|
||||
return new ItemFileInfo
|
||||
{
|
||||
Name = Path.GetFileName(path),
|
||||
Path = path,
|
||||
Type = ItemFileType.Subtitles,
|
||||
Index = subtitleStreamIndex
|
||||
};
|
||||
}
|
||||
|
||||
private const int DatabaseProgressUpdateIntervalSeconds = 2;
|
||||
|
||||
private async Task Sync(SyncJobItem jobItem, Audio item, User user, bool enableConversion, SyncOptions syncOptions, IProgress<double> progress, CancellationToken cancellationToken)
|
||||
{
|
||||
var job = _syncManager.GetJob(jobItem.JobId);
|
||||
var jobOptions = _syncManager.GetAudioOptions(jobItem, job);
|
||||
var conversionOptions = new AudioOptions
|
||||
{
|
||||
Profile = jobOptions.DeviceProfile
|
||||
};
|
||||
|
||||
conversionOptions.DeviceId = jobItem.TargetId;
|
||||
conversionOptions.Context = EncodingContext.Static;
|
||||
conversionOptions.ItemId = item.Id.ToString("N");
|
||||
conversionOptions.MediaSources = _mediaSourceManager.GetStaticMediaSources(item, false, user).ToList();
|
||||
|
||||
var streamInfo = new StreamBuilder(_mediaEncoder, _logger).BuildAudioItem(conversionOptions);
|
||||
var mediaSource = streamInfo.MediaSource;
|
||||
|
||||
jobItem.MediaSourceId = streamInfo.MediaSourceId;
|
||||
jobItem.TemporaryPath = GetTemporaryPath(jobItem);
|
||||
|
||||
if (streamInfo.PlayMethod == PlayMethod.Transcode && jobOptions.IsConverting)
|
||||
{
|
||||
if (!enableConversion)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
jobItem.Status = SyncJobItemStatus.Converting;
|
||||
await _syncManager.UpdateSyncJobItemInternal(jobItem).ConfigureAwait(false);
|
||||
await UpdateJobStatus(jobItem.JobId).ConfigureAwait(false);
|
||||
|
||||
try
|
||||
{
|
||||
var lastJobUpdate = DateTime.MinValue;
|
||||
var innerProgress = new ActionableProgress<double>();
|
||||
innerProgress.RegisterAction(async pct =>
|
||||
{
|
||||
progress.Report(pct);
|
||||
|
||||
if ((DateTime.UtcNow - lastJobUpdate).TotalSeconds >= DatabaseProgressUpdateIntervalSeconds)
|
||||
{
|
||||
jobItem.Progress = pct / 2;
|
||||
await _syncManager.UpdateSyncJobItemInternal(jobItem).ConfigureAwait(false);
|
||||
await UpdateJobStatus(jobItem.JobId).ConfigureAwait(false);
|
||||
}
|
||||
});
|
||||
|
||||
jobItem.OutputPath = await _mediaEncoder.EncodeAudio(new EncodingJobOptions(streamInfo, conversionOptions.Profile)
|
||||
{
|
||||
OutputDirectory = jobItem.TemporaryPath,
|
||||
CpuCoreLimit = syncOptions.TranscodingCpuCoreLimit
|
||||
|
||||
}, innerProgress, cancellationToken);
|
||||
|
||||
jobItem.ItemDateModifiedTicks = item.DateModified.Ticks;
|
||||
_syncManager.OnConversionComplete(jobItem);
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
jobItem.Status = SyncJobItemStatus.Queued;
|
||||
jobItem.Progress = 0;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
jobItem.Status = SyncJobItemStatus.Failed;
|
||||
_logger.ErrorException("Error during sync transcoding", ex);
|
||||
}
|
||||
|
||||
if (jobItem.Status == SyncJobItemStatus.Failed || jobItem.Status == SyncJobItemStatus.Queued)
|
||||
{
|
||||
await _syncManager.UpdateSyncJobItemInternal(jobItem).ConfigureAwait(false);
|
||||
return;
|
||||
}
|
||||
|
||||
jobItem.MediaSource = await GetEncodedMediaSource(jobItem.OutputPath, user, false).ConfigureAwait(false);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (mediaSource.Protocol == MediaProtocol.File)
|
||||
{
|
||||
jobItem.OutputPath = mediaSource.Path;
|
||||
}
|
||||
else if (mediaSource.Protocol == MediaProtocol.Http)
|
||||
{
|
||||
jobItem.OutputPath = await DownloadFile(jobItem, mediaSource, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new InvalidOperationException(string.Format("Cannot direct stream {0} protocol", mediaSource.Protocol));
|
||||
}
|
||||
|
||||
jobItem.ItemDateModifiedTicks = item.DateModified.Ticks;
|
||||
jobItem.MediaSource = mediaSource;
|
||||
}
|
||||
|
||||
jobItem.MediaSource.SupportsTranscoding = false;
|
||||
|
||||
jobItem.Progress = 50;
|
||||
jobItem.Status = SyncJobItemStatus.ReadyToTransfer;
|
||||
await _syncManager.UpdateSyncJobItemInternal(jobItem).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private async Task Sync(SyncJobItem jobItem, Photo item, CancellationToken cancellationToken)
|
||||
{
|
||||
jobItem.OutputPath = item.Path;
|
||||
|
||||
jobItem.Progress = 50;
|
||||
jobItem.Status = SyncJobItemStatus.ReadyToTransfer;
|
||||
jobItem.ItemDateModifiedTicks = item.DateModified.Ticks;
|
||||
await _syncManager.UpdateSyncJobItemInternal(jobItem).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private async Task SyncGeneric(SyncJobItem jobItem, BaseItem item, CancellationToken cancellationToken)
|
||||
{
|
||||
jobItem.OutputPath = item.Path;
|
||||
|
||||
jobItem.Progress = 50;
|
||||
jobItem.Status = SyncJobItemStatus.ReadyToTransfer;
|
||||
jobItem.ItemDateModifiedTicks = item.DateModified.Ticks;
|
||||
await _syncManager.UpdateSyncJobItemInternal(jobItem).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private async Task<string> DownloadFile(SyncJobItem jobItem, MediaSourceInfo mediaSource, CancellationToken cancellationToken)
|
||||
{
|
||||
// TODO: Download
|
||||
return mediaSource.Path;
|
||||
}
|
||||
|
||||
public string GetTemporaryPath(SyncJob job)
|
||||
{
|
||||
return GetTemporaryPath(job.Id);
|
||||
}
|
||||
|
||||
public string GetTemporaryPath(string jobId)
|
||||
{
|
||||
var basePath = _config.GetSyncOptions().TemporaryPath;
|
||||
|
||||
if (string.IsNullOrWhiteSpace(basePath))
|
||||
{
|
||||
basePath = Path.Combine(_config.CommonApplicationPaths.ProgramDataPath, "sync");
|
||||
}
|
||||
|
||||
return Path.Combine(basePath, jobId);
|
||||
}
|
||||
|
||||
public string GetTemporaryPath(SyncJobItem jobItem)
|
||||
{
|
||||
return Path.Combine(GetTemporaryPath(jobItem.JobId), jobItem.Id);
|
||||
}
|
||||
|
||||
private async Task<MediaSourceInfo> GetEncodedMediaSource(string path, User user, bool isVideo)
|
||||
{
|
||||
var item = _libraryManager.ResolvePath(_fileSystem.GetFileSystemInfo(path));
|
||||
|
||||
await item.RefreshMetadata(CancellationToken.None).ConfigureAwait(false);
|
||||
|
||||
var hasMediaSources = item as IHasMediaSources;
|
||||
|
||||
var mediaSources = _mediaSourceManager.GetStaticMediaSources(hasMediaSources, false).ToList();
|
||||
|
||||
var preferredAudio = string.IsNullOrEmpty(user.Configuration.AudioLanguagePreference)
|
||||
? new string[] { }
|
||||
: new[] { user.Configuration.AudioLanguagePreference };
|
||||
|
||||
var preferredSubs = string.IsNullOrEmpty(user.Configuration.SubtitleLanguagePreference)
|
||||
? new List<string>() : new List<string> { user.Configuration.SubtitleLanguagePreference };
|
||||
|
||||
foreach (var source in mediaSources)
|
||||
{
|
||||
if (isVideo)
|
||||
{
|
||||
source.DefaultAudioStreamIndex =
|
||||
MediaStreamSelector.GetDefaultAudioStreamIndex(source.MediaStreams, preferredAudio, user.Configuration.PlayDefaultAudioTrack);
|
||||
|
||||
var defaultAudioIndex = source.DefaultAudioStreamIndex;
|
||||
var audioLangage = defaultAudioIndex == null
|
||||
? null
|
||||
: source.MediaStreams.Where(i => i.Type == MediaStreamType.Audio && i.Index == defaultAudioIndex).Select(i => i.Language).FirstOrDefault();
|
||||
|
||||
source.DefaultAudioStreamIndex =
|
||||
MediaStreamSelector.GetDefaultSubtitleStreamIndex(source.MediaStreams, preferredSubs, user.Configuration.SubtitleMode, audioLangage);
|
||||
}
|
||||
else
|
||||
{
|
||||
var audio = source.MediaStreams.FirstOrDefault(i => i.Type == MediaStreamType.Audio);
|
||||
|
||||
if (audio != null)
|
||||
{
|
||||
source.DefaultAudioStreamIndex = audio.Index;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
return mediaSources.FirstOrDefault();
|
||||
}
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,48 +0,0 @@
|
||||
using System.Threading;
|
||||
using MediaBrowser.Controller.Plugins;
|
||||
using MediaBrowser.Controller.Session;
|
||||
using MediaBrowser.Controller.Sync;
|
||||
using MediaBrowser.Model.Events;
|
||||
using MediaBrowser.Model.Sync;
|
||||
|
||||
namespace MediaBrowser.Server.Implementations.Sync
|
||||
{
|
||||
public class SyncNotificationEntryPoint : IServerEntryPoint
|
||||
{
|
||||
private readonly ISessionManager _sessionManager;
|
||||
private readonly ISyncManager _syncManager;
|
||||
|
||||
public SyncNotificationEntryPoint(ISyncManager syncManager, ISessionManager sessionManager)
|
||||
{
|
||||
_syncManager = syncManager;
|
||||
_sessionManager = sessionManager;
|
||||
}
|
||||
|
||||
public void Run()
|
||||
{
|
||||
_syncManager.SyncJobItemUpdated += _syncManager_SyncJobItemUpdated;
|
||||
}
|
||||
|
||||
private async void _syncManager_SyncJobItemUpdated(object sender, GenericEventArgs<SyncJobItem> e)
|
||||
{
|
||||
var item = e.Argument;
|
||||
|
||||
if (item.Status == SyncJobItemStatus.ReadyToTransfer)
|
||||
{
|
||||
try
|
||||
{
|
||||
await _sessionManager.SendMessageToUserDeviceSessions(item.TargetId, "SyncJobItemReady", item, CancellationToken.None).ConfigureAwait(false);
|
||||
}
|
||||
catch
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
_syncManager.SyncJobItemUpdated -= _syncManager_SyncJobItemUpdated;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
using MediaBrowser.Common.Security;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace MediaBrowser.Server.Implementations.Sync
|
||||
{
|
||||
public class SyncRegistrationInfo : IRequiresRegistration
|
||||
{
|
||||
private readonly ISecurityManager _securityManager;
|
||||
|
||||
public static SyncRegistrationInfo Instance;
|
||||
|
||||
public SyncRegistrationInfo(ISecurityManager securityManager)
|
||||
{
|
||||
_securityManager = securityManager;
|
||||
Instance = this;
|
||||
}
|
||||
|
||||
private bool _registered;
|
||||
public bool IsRegistered
|
||||
{
|
||||
get { return _registered; }
|
||||
}
|
||||
|
||||
public async Task LoadRegistrationInfoAsync()
|
||||
{
|
||||
var info = await _securityManager.GetRegistrationStatus("sync").ConfigureAwait(false);
|
||||
|
||||
_registered = info.IsValid;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,158 +0,0 @@
|
||||
using MediaBrowser.Common.Extensions;
|
||||
using MediaBrowser.Controller;
|
||||
using MediaBrowser.Controller.Entities;
|
||||
using MediaBrowser.Controller.Library;
|
||||
using MediaBrowser.Controller.Sync;
|
||||
using MediaBrowser.Model.Dto;
|
||||
using MediaBrowser.Model.Logging;
|
||||
using MediaBrowser.Model.Sync;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace MediaBrowser.Server.Implementations.Sync
|
||||
{
|
||||
public class SyncedMediaSourceProvider : IMediaSourceProvider
|
||||
{
|
||||
private readonly SyncManager _syncManager;
|
||||
private readonly IServerApplicationHost _appHost;
|
||||
private readonly ILogger _logger;
|
||||
|
||||
public SyncedMediaSourceProvider(ISyncManager syncManager, IServerApplicationHost appHost, ILogger logger)
|
||||
{
|
||||
_appHost = appHost;
|
||||
_logger = logger;
|
||||
_syncManager = (SyncManager)syncManager;
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<MediaSourceInfo>> GetMediaSources(IHasMediaSources item, CancellationToken cancellationToken)
|
||||
{
|
||||
var jobItemResult = _syncManager.GetJobItems(new SyncJobItemQuery
|
||||
{
|
||||
AddMetadata = false,
|
||||
Statuses = new[] { SyncJobItemStatus.Synced },
|
||||
ItemId = item.Id.ToString("N")
|
||||
});
|
||||
|
||||
var list = new List<MediaSourceInfo>();
|
||||
|
||||
if (jobItemResult.Items.Length > 0)
|
||||
{
|
||||
var targets = _syncManager.ServerSyncProviders
|
||||
.SelectMany(i => i.GetAllSyncTargets().Select(t => new Tuple<IServerSyncProvider, SyncTarget>(i, t)))
|
||||
.ToList();
|
||||
|
||||
var serverId = _appHost.SystemId;
|
||||
|
||||
foreach (var jobItem in jobItemResult.Items)
|
||||
{
|
||||
var targetTuple = targets.FirstOrDefault(i => string.Equals(i.Item2.Id, jobItem.TargetId, StringComparison.OrdinalIgnoreCase));
|
||||
|
||||
if (targetTuple != null)
|
||||
{
|
||||
var syncTarget = targetTuple.Item2;
|
||||
var syncProvider = targetTuple.Item1;
|
||||
var dataProvider = _syncManager.GetDataProvider(targetTuple.Item1, syncTarget);
|
||||
|
||||
var localItems = await dataProvider.GetItems(syncTarget, serverId, item.Id.ToString("N")).ConfigureAwait(false);
|
||||
|
||||
foreach (var localItem in localItems)
|
||||
{
|
||||
foreach (var mediaSource in localItem.Item.MediaSources)
|
||||
{
|
||||
AddMediaSource(list, localItem, mediaSource, syncProvider, syncTarget);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return list;
|
||||
}
|
||||
|
||||
private void AddMediaSource(List<MediaSourceInfo> list,
|
||||
LocalItem item,
|
||||
MediaSourceInfo mediaSource,
|
||||
IServerSyncProvider provider,
|
||||
SyncTarget target)
|
||||
{
|
||||
SetStaticMediaSourceInfo(item, mediaSource);
|
||||
|
||||
var requiresDynamicAccess = provider as IHasDynamicAccess;
|
||||
|
||||
if (requiresDynamicAccess != null)
|
||||
{
|
||||
mediaSource.RequiresOpening = true;
|
||||
|
||||
var keyList = new List<string>();
|
||||
keyList.Add(provider.GetType().FullName.GetMD5().ToString("N"));
|
||||
keyList.Add(target.Id.GetMD5().ToString("N"));
|
||||
keyList.Add(item.Id);
|
||||
mediaSource.OpenToken = string.Join(StreamIdDelimeterString, keyList.ToArray());
|
||||
}
|
||||
|
||||
list.Add(mediaSource);
|
||||
}
|
||||
|
||||
// Do not use a pipe here because Roku http requests to the server will fail, without any explicit error message.
|
||||
private const string StreamIdDelimeterString = "_";
|
||||
|
||||
public async Task<Tuple<MediaSourceInfo, IDirectStreamProvider>> OpenMediaSource(string openToken, CancellationToken cancellationToken)
|
||||
{
|
||||
var openKeys = openToken.Split(new[] { StreamIdDelimeterString[0] }, 3);
|
||||
|
||||
var provider = _syncManager.ServerSyncProviders
|
||||
.FirstOrDefault(i => string.Equals(openKeys[0], i.GetType().FullName.GetMD5().ToString("N"), StringComparison.OrdinalIgnoreCase));
|
||||
|
||||
var target = provider.GetAllSyncTargets()
|
||||
.FirstOrDefault(i => string.Equals(openKeys[1], i.Id.GetMD5().ToString("N"), StringComparison.OrdinalIgnoreCase));
|
||||
|
||||
var dataProvider = _syncManager.GetDataProvider(provider, target);
|
||||
var localItem = await dataProvider.Get(target, openKeys[2]).ConfigureAwait(false);
|
||||
|
||||
var fileId = localItem.FileId;
|
||||
if (string.IsNullOrWhiteSpace(fileId))
|
||||
{
|
||||
}
|
||||
|
||||
var requiresDynamicAccess = (IHasDynamicAccess)provider;
|
||||
var dynamicInfo = await requiresDynamicAccess.GetSyncedFileInfo(fileId, target, cancellationToken).ConfigureAwait(false);
|
||||
|
||||
var mediaSource = localItem.Item.MediaSources.First();
|
||||
mediaSource.LiveStreamId = Guid.NewGuid().ToString();
|
||||
SetStaticMediaSourceInfo(localItem, mediaSource);
|
||||
|
||||
foreach (var stream in mediaSource.MediaStreams)
|
||||
{
|
||||
if (!string.IsNullOrWhiteSpace(stream.ExternalId))
|
||||
{
|
||||
var dynamicStreamInfo = await requiresDynamicAccess.GetSyncedFileInfo(stream.ExternalId, target, cancellationToken).ConfigureAwait(false);
|
||||
stream.Path = dynamicStreamInfo.Path;
|
||||
}
|
||||
}
|
||||
|
||||
mediaSource.Path = dynamicInfo.Path;
|
||||
mediaSource.Protocol = dynamicInfo.Protocol;
|
||||
mediaSource.RequiredHttpHeaders = dynamicInfo.RequiredHttpHeaders;
|
||||
|
||||
return new Tuple<MediaSourceInfo, IDirectStreamProvider>(mediaSource, null);
|
||||
}
|
||||
|
||||
private void SetStaticMediaSourceInfo(LocalItem item, MediaSourceInfo mediaSource)
|
||||
{
|
||||
mediaSource.Id = item.Id;
|
||||
mediaSource.SupportsTranscoding = false;
|
||||
if (mediaSource.Protocol == Model.MediaInfo.MediaProtocol.File)
|
||||
{
|
||||
mediaSource.ETag = item.Id;
|
||||
}
|
||||
}
|
||||
|
||||
public Task CloseMediaSource(string liveStreamId)
|
||||
{
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,188 +0,0 @@
|
||||
using MediaBrowser.Common.Configuration;
|
||||
using MediaBrowser.Controller;
|
||||
using MediaBrowser.Controller.Sync;
|
||||
using MediaBrowser.Model.Logging;
|
||||
using MediaBrowser.Model.Serialization;
|
||||
using MediaBrowser.Model.Sync;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using MediaBrowser.Model.IO;
|
||||
|
||||
namespace MediaBrowser.Server.Implementations.Sync
|
||||
{
|
||||
public class TargetDataProvider : ISyncDataProvider
|
||||
{
|
||||
private readonly SyncTarget _target;
|
||||
private readonly IServerSyncProvider _provider;
|
||||
|
||||
private readonly SemaphoreSlim _dataLock = new SemaphoreSlim(1, 1);
|
||||
private List<LocalItem> _items;
|
||||
|
||||
private readonly ILogger _logger;
|
||||
private readonly IJsonSerializer _json;
|
||||
private readonly IFileSystem _fileSystem;
|
||||
private readonly IApplicationPaths _appPaths;
|
||||
private readonly IServerApplicationHost _appHost;
|
||||
private readonly IMemoryStreamProvider _memoryStreamProvider;
|
||||
|
||||
public TargetDataProvider(IServerSyncProvider provider, SyncTarget target, IServerApplicationHost appHost, ILogger logger, IJsonSerializer json, IFileSystem fileSystem, IApplicationPaths appPaths, IMemoryStreamProvider memoryStreamProvider)
|
||||
{
|
||||
_logger = logger;
|
||||
_json = json;
|
||||
_provider = provider;
|
||||
_target = target;
|
||||
_fileSystem = fileSystem;
|
||||
_appPaths = appPaths;
|
||||
_memoryStreamProvider = memoryStreamProvider;
|
||||
_appHost = appHost;
|
||||
}
|
||||
|
||||
private string[] GetRemotePath()
|
||||
{
|
||||
var parts = new List<string>
|
||||
{
|
||||
_appHost.FriendlyName,
|
||||
"data.json"
|
||||
};
|
||||
|
||||
parts = parts.Select(i => GetValidFilename(_provider, i)).ToList();
|
||||
|
||||
return parts.ToArray();
|
||||
}
|
||||
|
||||
private string GetValidFilename(IServerSyncProvider provider, string filename)
|
||||
{
|
||||
// We can always add this method to the sync provider if it's really needed
|
||||
return _fileSystem.GetValidFilename(filename);
|
||||
}
|
||||
|
||||
private async Task<List<LocalItem>> RetrieveItems(CancellationToken cancellationToken)
|
||||
{
|
||||
_logger.Debug("Getting {0} from {1}", string.Join(MediaSync.PathSeparatorString, GetRemotePath().ToArray()), _provider.Name);
|
||||
|
||||
var fileResult = await _provider.GetFiles(GetRemotePath().ToArray(), _target, cancellationToken).ConfigureAwait(false);
|
||||
|
||||
if (fileResult.Items.Length > 0)
|
||||
{
|
||||
using (var stream = await _provider.GetFile(fileResult.Items[0].FullName, _target, new Progress<double>(), cancellationToken))
|
||||
{
|
||||
return _json.DeserializeFromStream<List<LocalItem>>(stream);
|
||||
}
|
||||
}
|
||||
|
||||
return new List<LocalItem>();
|
||||
}
|
||||
|
||||
private async Task EnsureData(CancellationToken cancellationToken)
|
||||
{
|
||||
if (_items == null)
|
||||
{
|
||||
_items = await RetrieveItems(cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
}
|
||||
|
||||
private async Task SaveData(List<LocalItem> items, CancellationToken cancellationToken)
|
||||
{
|
||||
using (var stream = _memoryStreamProvider.CreateNew())
|
||||
{
|
||||
_json.SerializeToStream(items, stream);
|
||||
|
||||
// Save to sync provider
|
||||
stream.Position = 0;
|
||||
var remotePath = GetRemotePath();
|
||||
_logger.Debug("Saving data.json to {0}. Remote path: {1}", _provider.Name, string.Join("/", remotePath));
|
||||
|
||||
await _provider.SendFile(stream, remotePath, _target, new Progress<double>(), cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
}
|
||||
|
||||
private async Task<T> GetData<T>(bool enableCache, Func<List<LocalItem>, T> dataFactory)
|
||||
{
|
||||
if (!enableCache)
|
||||
{
|
||||
var items = await RetrieveItems(CancellationToken.None).ConfigureAwait(false);
|
||||
var newCache = items.ToList();
|
||||
var result = dataFactory(items);
|
||||
await UpdateCache(newCache).ConfigureAwait(false);
|
||||
return result;
|
||||
}
|
||||
|
||||
await _dataLock.WaitAsync().ConfigureAwait(false);
|
||||
|
||||
try
|
||||
{
|
||||
await EnsureData(CancellationToken.None).ConfigureAwait(false);
|
||||
|
||||
return dataFactory(_items);
|
||||
}
|
||||
finally
|
||||
{
|
||||
_dataLock.Release();
|
||||
}
|
||||
}
|
||||
|
||||
private async Task UpdateData(Func<List<LocalItem>, List<LocalItem>> action)
|
||||
{
|
||||
var items = await RetrieveItems(CancellationToken.None).ConfigureAwait(false);
|
||||
items = action(items);
|
||||
await SaveData(items.ToList(), CancellationToken.None).ConfigureAwait(false);
|
||||
|
||||
await UpdateCache(null).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private async Task UpdateCache(List<LocalItem> list)
|
||||
{
|
||||
await _dataLock.WaitAsync().ConfigureAwait(false);
|
||||
|
||||
try
|
||||
{
|
||||
_items = list;
|
||||
}
|
||||
finally
|
||||
{
|
||||
_dataLock.Release();
|
||||
}
|
||||
}
|
||||
|
||||
public Task<List<LocalItem>> GetLocalItems(SyncTarget target, string serverId)
|
||||
{
|
||||
return GetData(false, items => items.Where(i => string.Equals(i.ServerId, serverId, StringComparison.OrdinalIgnoreCase)).ToList());
|
||||
}
|
||||
|
||||
public Task AddOrUpdate(SyncTarget target, LocalItem item)
|
||||
{
|
||||
return UpdateData(items =>
|
||||
{
|
||||
var list = items.Where(i => !string.Equals(i.Id, item.Id, StringComparison.OrdinalIgnoreCase))
|
||||
.ToList();
|
||||
|
||||
list.Add(item);
|
||||
|
||||
return list;
|
||||
});
|
||||
}
|
||||
|
||||
public Task Delete(SyncTarget target, string id)
|
||||
{
|
||||
return UpdateData(items => items.Where(i => !string.Equals(i.Id, id, StringComparison.OrdinalIgnoreCase)).ToList());
|
||||
}
|
||||
|
||||
public Task<LocalItem> Get(SyncTarget target, string id)
|
||||
{
|
||||
return GetData(true, items => items.FirstOrDefault(i => string.Equals(i.Id, id, StringComparison.OrdinalIgnoreCase)));
|
||||
}
|
||||
|
||||
public Task<List<LocalItem>> GetItems(SyncTarget target, string serverId, string itemId)
|
||||
{
|
||||
return GetData(true, items => items.Where(i => string.Equals(i.ServerId, serverId, StringComparison.OrdinalIgnoreCase) && string.Equals(i.ItemId, itemId, StringComparison.OrdinalIgnoreCase)).ToList());
|
||||
}
|
||||
|
||||
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());
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user