move sync repository to portable project

pull/702/head
Luke Pulverenti 8 years ago
parent e58e34ceca
commit 65a1ef020b

@ -4,7 +4,6 @@ using Emby.Common.Implementations.Devices;
using Emby.Common.Implementations.IO;
using Emby.Common.Implementations.ScheduledTasks;
using Emby.Common.Implementations.Serialization;
using Emby.Common.Implementations.Updates;
using MediaBrowser.Common.Net;
using MediaBrowser.Common.Plugins;
using MediaBrowser.Common.Progress;

@ -55,25 +55,6 @@ namespace Emby.Common.Implementations.ScheduledTasks
private ILogger Logger { get; set; }
private readonly IFileSystem _fileSystem;
private bool _suspendTriggers;
public bool SuspendTriggers
{
get { return _suspendTriggers; }
set
{
Logger.Info("Setting SuspendTriggers to {0}", value);
var executeQueued = _suspendTriggers && !value;
_suspendTriggers = value;
if (executeQueued)
{
ExecuteQueuedTasks();
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TaskManager" /> class.
/// </summary>
@ -230,7 +211,7 @@ namespace Emby.Common.Implementations.ScheduledTasks
lock (_taskQueue)
{
if (task.State == TaskState.Idle && !SuspendTriggers)
if (task.State == TaskState.Idle)
{
Execute(task, options);
return;
@ -322,11 +303,6 @@ namespace Emby.Common.Implementations.ScheduledTasks
/// </summary>
private void ExecuteQueuedTasks()
{
if (SuspendTriggers)
{
return;
}
Logger.Info("ExecuteQueuedTasks");
// Execute queued tasks

@ -65,7 +65,6 @@ using Emby.Common.Implementations.Networking;
using Emby.Common.Implementations.Reflection;
using Emby.Common.Implementations.Serialization;
using Emby.Common.Implementations.TextEncoding;
using Emby.Common.Implementations.Updates;
using Emby.Common.Implementations.Xml;
using Emby.Photos;
using MediaBrowser.Model.IO;
@ -90,10 +89,10 @@ using Emby.Server.Implementations.Devices;
using Emby.Server.Implementations.FFMpeg;
using Emby.Server.Core.IO;
using Emby.Server.Core.Localization;
using Emby.Server.Core.Migrations;
using Emby.Server.Implementations.Migrations;
using Emby.Server.Implementations.Security;
using Emby.Server.Implementations.Social;
using Emby.Server.Core.Sync;
using Emby.Server.Implementations.Sync;
using Emby.Server.Implementations.Channels;
using Emby.Server.Implementations.Collections;
using Emby.Server.Implementations.Connect;
@ -357,12 +356,6 @@ namespace Emby.Server.Core
{
await PerformPreInitMigrations().ConfigureAwait(false);
if (ServerConfigurationManager.Configuration.MigrationVersion < CleanDatabaseScheduledTask.MigrationVersion &&
ServerConfigurationManager.Configuration.IsStartupWizardCompleted)
{
TaskManager.SuspendTriggers = true;
}
await base.RunStartupTasks().ConfigureAwait(false);
await MediaEncoder.Init().ConfigureAwait(false);
@ -494,7 +487,6 @@ namespace Emby.Server.Core
{
var migrations = new List<IVersionMigration>
{
new DbMigration(ServerConfigurationManager, TaskManager)
};
foreach (var task in migrations)
@ -568,7 +560,7 @@ namespace Emby.Server.Core
AuthenticationRepository = await GetAuthenticationRepository().ConfigureAwait(false);
RegisterSingleInstance(AuthenticationRepository);
SyncRepository = await GetSyncRepository().ConfigureAwait(false);
SyncRepository = GetSyncRepository();
RegisterSingleInstance(SyncRepository);
UserManager = new UserManager(LogManager.GetLogger("UserManager"), ServerConfigurationManager, UserRepository, XmlSerializer, NetworkManager, () => ImageProcessor, () => DtoService, () => ConnectManager, this, JsonSerializer, FileSystemManager, CryptographyProvider, _defaultUserNameFactory());
@ -591,7 +583,7 @@ namespace Emby.Server.Core
CertificatePath = GetCertificatePath(true);
Certificate = GetCertificate(CertificatePath);
HttpServer = HttpServerFactory.CreateServer(this, LogManager, ServerConfigurationManager, NetworkManager, MemoryStreamFactory, "Emby", "web/index.html", textEncoding, SocketFactory, CryptographyProvider, JsonSerializer, XmlSerializer, EnvironmentInfo, Certificate);
HttpServer = HttpServerFactory.CreateServer(this, LogManager, ServerConfigurationManager, NetworkManager, MemoryStreamFactory, "Emby", "web/index.html", textEncoding, SocketFactory, CryptographyProvider, JsonSerializer, XmlSerializer, EnvironmentInfo, Certificate, SupportsDualModeSockets);
HttpServer.GlobalResponse = LocalizationManager.GetLocalizedString("StartupEmbyServerIsLoading");
RegisterSingleInstance(HttpServer, false);
progress.Report(10);
@ -714,6 +706,8 @@ namespace Emby.Server.Core
await ((UserManager)UserManager).Initialize().ConfigureAwait(false);
}
protected abstract bool SupportsDualModeSockets { get; }
private ICertificate GetCertificate(string certificateLocation)
{
if (string.IsNullOrWhiteSpace(certificateLocation))
@ -844,11 +838,11 @@ namespace Emby.Server.Core
return repo;
}
private async Task<ISyncRepository> GetSyncRepository()
private ISyncRepository GetSyncRepository()
{
var repo = new SyncRepository(LogManager, JsonSerializer, ServerConfigurationManager.ApplicationPaths, GetDbConnector());
var repo = new SyncRepository(LogManager.GetLogger("SyncRepository"), JsonSerializer, ServerConfigurationManager.ApplicationPaths);
await repo.Initialize().ConfigureAwait(false);
repo.Initialize();
return repo;
}

@ -3060,18 +3060,6 @@ namespace Emby.Server.Core.Data
{
//whereClauses.Add("(UserId is null or UserId=@UserId)");
}
if (query.IsCurrentSchema.HasValue)
{
if (query.IsCurrentSchema.Value)
{
whereClauses.Add("(SchemaVersion not null AND SchemaVersion=@SchemaVersion)");
}
else
{
whereClauses.Add("(SchemaVersion is null or SchemaVersion<>@SchemaVersion)");
}
cmd.Parameters.Add(cmd, "@SchemaVersion", DbType.Int32).Value = LatestSchemaVersion;
}
if (query.IsHD.HasValue)
{
whereClauses.Add("IsHD=@IsHD");
@ -3454,7 +3442,7 @@ namespace Emby.Server.Core.Data
cmd.Parameters.Add(cmd, "@NameLessThan", DbType.String).Value = query.NameLessThan.ToLower();
}
if (query.ImageTypes.Length > 0 && _config.Configuration.SchemaVersion >= 87)
if (query.ImageTypes.Length > 0)
{
foreach (var requiredImage in query.ImageTypes)
{
@ -3738,15 +3726,8 @@ namespace Emby.Server.Core.Data
}
if (query.IsVirtualItem.HasValue)
{
if (_config.Configuration.SchemaVersion >= 90)
{
whereClauses.Add("IsVirtualItem=@IsVirtualItem");
cmd.Parameters.Add(cmd, "@IsVirtualItem", DbType.Boolean).Value = query.IsVirtualItem.Value;
}
else if (!query.IsVirtualItem.Value)
{
whereClauses.Add("LocationType<>'Virtual'");
}
whereClauses.Add("IsVirtualItem=@IsVirtualItem");
cmd.Parameters.Add(cmd, "@IsVirtualItem", DbType.Boolean).Value = query.IsVirtualItem.Value;
}
if (query.IsSpecialSeason.HasValue)
{
@ -3770,7 +3751,7 @@ namespace Emby.Server.Core.Data
whereClauses.Add("PremiereDate < DATETIME('now')");
}
}
if (query.IsMissing.HasValue && _config.Configuration.SchemaVersion >= 90)
if (query.IsMissing.HasValue)
{
if (query.IsMissing.Value)
{
@ -3781,7 +3762,7 @@ namespace Emby.Server.Core.Data
whereClauses.Add("(IsVirtualItem=0 OR PremiereDate >= DATETIME('now'))");
}
}
if (query.IsVirtualUnaired.HasValue && _config.Configuration.SchemaVersion >= 90)
if (query.IsVirtualUnaired.HasValue)
{
if (query.IsVirtualUnaired.Value)
{

@ -95,7 +95,7 @@ namespace Emby.Server.Core.EntryPoints
NatUtility.StartDiscovery();
_timer = _timerFactory.Create(ClearCreatedRules, null, TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(5));
_timer = _timerFactory.Create(ClearCreatedRules, null, TimeSpan.FromMinutes(10), TimeSpan.FromMinutes(10));
_deviceDiscovery.DeviceDiscovered += _deviceDiscovery_DeviceDiscovered;
@ -233,6 +233,7 @@ namespace Emby.Server.Core.EntryPoints
await device.CreatePortMap(new Mapping(Protocol.Tcp, privatePort, publicPort)
{
Description = _appHost.Name
}).ConfigureAwait(false);
}
catch (Exception ex)

@ -44,7 +44,8 @@ namespace Emby.Server.Core
IJsonSerializer json,
IXmlSerializer xml,
IEnvironmentInfo environment,
ICertificate certificate)
ICertificate certificate,
bool enableDualModeSockets)
{
var logger = logManager.GetLogger("HttpServer");
@ -63,7 +64,8 @@ namespace Emby.Server.Core
environment,
certificate,
new StreamFactory(),
GetParseFn);
GetParseFn,
enableDualModeSockets);
}
private static Func<string, object> GetParseFn(Type propertyType)

@ -1,64 +0,0 @@
using System.Threading.Tasks;
using Emby.Server.Implementations.Data;
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Model.Tasks;
using Emby.Server.Core.Data;
using Emby.Server.Implementations.Migrations;
namespace Emby.Server.Core.Migrations
{
public class DbMigration : IVersionMigration
{
private readonly IServerConfigurationManager _config;
private readonly ITaskManager _taskManager;
public DbMigration(IServerConfigurationManager config, ITaskManager taskManager)
{
_config = config;
_taskManager = taskManager;
}
public async Task Run()
{
// If a forced migration is required, do that now
if (_config.Configuration.MigrationVersion < CleanDatabaseScheduledTask.MigrationVersion)
{
if (!_config.Configuration.IsStartupWizardCompleted)
{
_config.Configuration.MigrationVersion = CleanDatabaseScheduledTask.MigrationVersion;
_config.SaveConfiguration();
return;
}
_taskManager.SuspendTriggers = true;
CleanDatabaseScheduledTask.EnableUnavailableMessage = true;
Task.Run(async () =>
{
await Task.Delay(1000).ConfigureAwait(false);
_taskManager.Execute<CleanDatabaseScheduledTask>();
});
return;
}
if (_config.Configuration.SchemaVersion < SqliteItemRepository.LatestSchemaVersion)
{
if (!_config.Configuration.IsStartupWizardCompleted)
{
_config.Configuration.SchemaVersion = SqliteItemRepository.LatestSchemaVersion;
_config.SaveConfiguration();
return;
}
Task.Run(async () =>
{
await Task.Delay(1000).ConfigureAwait(false);
_taskManager.Execute<CleanDatabaseScheduledTask>();
});
}
}
}
}

@ -1,976 +0,0 @@
using System;
using System.Collections.Generic;
using System.Data;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Emby.Server.Core.Data;
using MediaBrowser.Controller;
using MediaBrowser.Controller.Sync;
using MediaBrowser.Model.Dto;
using MediaBrowser.Model.Logging;
using MediaBrowser.Model.Querying;
using MediaBrowser.Model.Serialization;
using MediaBrowser.Model.Sync;
namespace Emby.Server.Core.Sync
{
public class SyncRepository : BaseSqliteRepository, ISyncRepository
{
private readonly CultureInfo _usCulture = new CultureInfo("en-US");
private readonly IJsonSerializer _json;
public SyncRepository(ILogManager logManager, IJsonSerializer json, IServerApplicationPaths appPaths, IDbConnector connector)
: base(logManager, connector)
{
_json = json;
DbFilePath = Path.Combine(appPaths.DataPath, "sync14.db");
}
private class SyncSummary
{
public Dictionary<string, int> Items { get; set; }
public SyncSummary()
{
Items = new Dictionary<string, int>();
}
}
public async Task Initialize()
{
using (var connection = await CreateConnection().ConfigureAwait(false))
{
string[] queries = {
"create table if not exists SyncJobs (Id GUID PRIMARY KEY, TargetId TEXT NOT NULL, Name TEXT NOT NULL, Profile TEXT, Quality TEXT, Bitrate INT, Status TEXT NOT NULL, Progress FLOAT, UserId TEXT NOT NULL, ItemIds TEXT NOT NULL, Category TEXT, ParentId TEXT, UnwatchedOnly BIT, ItemLimit INT, SyncNewContent BIT, DateCreated DateTime, DateLastModified DateTime, ItemCount int)",
"create table if not exists SyncJobItems (Id GUID PRIMARY KEY, ItemId TEXT, ItemName TEXT, MediaSourceId TEXT, JobId TEXT, TemporaryPath TEXT, OutputPath TEXT, Status TEXT, TargetId TEXT, DateCreated DateTime, Progress FLOAT, AdditionalFiles TEXT, MediaSource TEXT, IsMarkedForRemoval BIT, JobItemIndex INT, ItemDateModifiedTicks BIGINT)",
"drop index if exists idx_SyncJobItems2",
"drop index if exists idx_SyncJobItems3",
"drop index if exists idx_SyncJobs1",
"drop index if exists idx_SyncJobs",
"drop index if exists idx_SyncJobItems1",
"create index if not exists idx_SyncJobItems4 on SyncJobItems(TargetId,ItemId,Status,Progress,DateCreated)",
"create index if not exists idx_SyncJobItems5 on SyncJobItems(TargetId,Status,ItemId,Progress)",
"create index if not exists idx_SyncJobs2 on SyncJobs(TargetId,Status,ItemIds,Progress)",
"pragma shrink_memory"
};
connection.RunQueries(queries, Logger);
connection.AddColumn(Logger, "SyncJobs", "Profile", "TEXT");
connection.AddColumn(Logger, "SyncJobs", "Bitrate", "INT");
connection.AddColumn(Logger, "SyncJobItems", "ItemDateModifiedTicks", "BIGINT");
}
}
private const string BaseJobSelectText = "select Id, TargetId, Name, Profile, Quality, Bitrate, Status, Progress, UserId, ItemIds, Category, ParentId, UnwatchedOnly, ItemLimit, SyncNewContent, DateCreated, DateLastModified, ItemCount from SyncJobs";
private const string BaseJobItemSelectText = "select Id, ItemId, ItemName, MediaSourceId, JobId, TemporaryPath, OutputPath, Status, TargetId, DateCreated, Progress, AdditionalFiles, MediaSource, IsMarkedForRemoval, JobItemIndex, ItemDateModifiedTicks from SyncJobItems";
public SyncJob GetJob(string id)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentNullException("id");
}
CheckDisposed();
var guid = new Guid(id);
if (guid == Guid.Empty)
{
throw new ArgumentNullException("id");
}
using (var connection = CreateConnection(true).Result)
{
using (var cmd = connection.CreateCommand())
{
cmd.CommandText = BaseJobSelectText + " where Id=@Id";
cmd.Parameters.Add(cmd, "@Id", DbType.Guid).Value = guid;
using (var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess | CommandBehavior.SingleResult | CommandBehavior.SingleRow))
{
if (reader.Read())
{
return GetJob(reader);
}
}
}
return null;
}
}
private SyncJob GetJob(IDataReader reader)
{
var info = new SyncJob
{
Id = reader.GetGuid(0).ToString("N"),
TargetId = reader.GetString(1),
Name = reader.GetString(2)
};
if (!reader.IsDBNull(3))
{
info.Profile = reader.GetString(3);
}
if (!reader.IsDBNull(4))
{
info.Quality = reader.GetString(4);
}
if (!reader.IsDBNull(5))
{
info.Bitrate = reader.GetInt32(5);
}
if (!reader.IsDBNull(6))
{
info.Status = (SyncJobStatus)Enum.Parse(typeof(SyncJobStatus), reader.GetString(6), true);
}
if (!reader.IsDBNull(7))
{
info.Progress = reader.GetDouble(7);
}
if (!reader.IsDBNull(8))
{
info.UserId = reader.GetString(8);
}
if (!reader.IsDBNull(9))
{
info.RequestedItemIds = reader.GetString(9).Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToList();
}
if (!reader.IsDBNull(10))
{
info.Category = (SyncCategory)Enum.Parse(typeof(SyncCategory), reader.GetString(10), true);
}
if (!reader.IsDBNull(11))
{
info.ParentId = reader.GetString(11);
}
if (!reader.IsDBNull(12))
{
info.UnwatchedOnly = reader.GetBoolean(12);
}
if (!reader.IsDBNull(13))
{
info.ItemLimit = reader.GetInt32(13);
}
info.SyncNewContent = reader.GetBoolean(14);
info.DateCreated = reader.GetDateTime(15).ToUniversalTime();
info.DateLastModified = reader.GetDateTime(16).ToUniversalTime();
info.ItemCount = reader.GetInt32(17);
return info;
}
public Task Create(SyncJob job)
{
return InsertOrUpdate(job, true);
}
public Task Update(SyncJob job)
{
return InsertOrUpdate(job, false);
}
private async Task InsertOrUpdate(SyncJob job, bool insert)
{
if (job == null)
{
throw new ArgumentNullException("job");
}
CheckDisposed();
using (var connection = await CreateConnection().ConfigureAwait(false))
{
using (var cmd = connection.CreateCommand())
{
if (insert)
{
cmd.CommandText = "insert into SyncJobs (Id, TargetId, Name, Profile, Quality, Bitrate, Status, Progress, UserId, ItemIds, Category, ParentId, UnwatchedOnly, ItemLimit, SyncNewContent, DateCreated, DateLastModified, ItemCount) values (@Id, @TargetId, @Name, @Profile, @Quality, @Bitrate, @Status, @Progress, @UserId, @ItemIds, @Category, @ParentId, @UnwatchedOnly, @ItemLimit, @SyncNewContent, @DateCreated, @DateLastModified, @ItemCount)";
cmd.Parameters.Add(cmd, "@Id");
cmd.Parameters.Add(cmd, "@TargetId");
cmd.Parameters.Add(cmd, "@Name");
cmd.Parameters.Add(cmd, "@Profile");
cmd.Parameters.Add(cmd, "@Quality");
cmd.Parameters.Add(cmd, "@Bitrate");
cmd.Parameters.Add(cmd, "@Status");
cmd.Parameters.Add(cmd, "@Progress");
cmd.Parameters.Add(cmd, "@UserId");
cmd.Parameters.Add(cmd, "@ItemIds");
cmd.Parameters.Add(cmd, "@Category");
cmd.Parameters.Add(cmd, "@ParentId");
cmd.Parameters.Add(cmd, "@UnwatchedOnly");
cmd.Parameters.Add(cmd, "@ItemLimit");
cmd.Parameters.Add(cmd, "@SyncNewContent");
cmd.Parameters.Add(cmd, "@DateCreated");
cmd.Parameters.Add(cmd, "@DateLastModified");
cmd.Parameters.Add(cmd, "@ItemCount");
}
else
{
cmd.CommandText = "update SyncJobs set TargetId=@TargetId,Name=@Name,Profile=@Profile,Quality=@Quality,Bitrate=@Bitrate,Status=@Status,Progress=@Progress,UserId=@UserId,ItemIds=@ItemIds,Category=@Category,ParentId=@ParentId,UnwatchedOnly=@UnwatchedOnly,ItemLimit=@ItemLimit,SyncNewContent=@SyncNewContent,DateCreated=@DateCreated,DateLastModified=@DateLastModified,ItemCount=@ItemCount where Id=@Id";
cmd.Parameters.Add(cmd, "@Id");
cmd.Parameters.Add(cmd, "@TargetId");
cmd.Parameters.Add(cmd, "@Name");
cmd.Parameters.Add(cmd, "@Profile");
cmd.Parameters.Add(cmd, "@Quality");
cmd.Parameters.Add(cmd, "@Bitrate");
cmd.Parameters.Add(cmd, "@Status");
cmd.Parameters.Add(cmd, "@Progress");
cmd.Parameters.Add(cmd, "@UserId");
cmd.Parameters.Add(cmd, "@ItemIds");
cmd.Parameters.Add(cmd, "@Category");
cmd.Parameters.Add(cmd, "@ParentId");
cmd.Parameters.Add(cmd, "@UnwatchedOnly");
cmd.Parameters.Add(cmd, "@ItemLimit");
cmd.Parameters.Add(cmd, "@SyncNewContent");
cmd.Parameters.Add(cmd, "@DateCreated");
cmd.Parameters.Add(cmd, "@DateLastModified");
cmd.Parameters.Add(cmd, "@ItemCount");
}
IDbTransaction transaction = null;
try
{
transaction = connection.BeginTransaction();
var index = 0;
cmd.GetParameter(index++).Value = new Guid(job.Id);
cmd.GetParameter(index++).Value = job.TargetId;
cmd.GetParameter(index++).Value = job.Name;
cmd.GetParameter(index++).Value = job.Profile;
cmd.GetParameter(index++).Value = job.Quality;
cmd.GetParameter(index++).Value = job.Bitrate;
cmd.GetParameter(index++).Value = job.Status.ToString();
cmd.GetParameter(index++).Value = job.Progress;
cmd.GetParameter(index++).Value = job.UserId;
cmd.GetParameter(index++).Value = string.Join(",", job.RequestedItemIds.ToArray());
cmd.GetParameter(index++).Value = job.Category;
cmd.GetParameter(index++).Value = job.ParentId;
cmd.GetParameter(index++).Value = job.UnwatchedOnly;
cmd.GetParameter(index++).Value = job.ItemLimit;
cmd.GetParameter(index++).Value = job.SyncNewContent;
cmd.GetParameter(index++).Value = job.DateCreated;
cmd.GetParameter(index++).Value = job.DateLastModified;
cmd.GetParameter(index++).Value = job.ItemCount;
cmd.Transaction = transaction;
cmd.ExecuteNonQuery();
transaction.Commit();
}
catch (OperationCanceledException)
{
if (transaction != null)
{
transaction.Rollback();
}
throw;
}
catch (Exception e)
{
Logger.ErrorException("Failed to save record:", e);
if (transaction != null)
{
transaction.Rollback();
}
throw;
}
finally
{
if (transaction != null)
{
transaction.Dispose();
}
}
}
}
}
public async Task DeleteJob(string id)
{
if (string.IsNullOrWhiteSpace(id))
{
throw new ArgumentNullException("id");
}
CheckDisposed();
using (var connection = await CreateConnection().ConfigureAwait(false))
{
using (var deleteJobCommand = connection.CreateCommand())
{
using (var deleteJobItemsCommand = connection.CreateCommand())
{
IDbTransaction transaction = null;
try
{
// _deleteJobCommand
deleteJobCommand.CommandText = "delete from SyncJobs where Id=@Id";
deleteJobCommand.Parameters.Add(deleteJobCommand, "@Id");
transaction = connection.BeginTransaction();
deleteJobCommand.GetParameter(0).Value = new Guid(id);
deleteJobCommand.Transaction = transaction;
deleteJobCommand.ExecuteNonQuery();
// _deleteJobItemsCommand
deleteJobItemsCommand.CommandText = "delete from SyncJobItems where JobId=@JobId";
deleteJobItemsCommand.Parameters.Add(deleteJobItemsCommand, "@JobId");
deleteJobItemsCommand.GetParameter(0).Value = id;
deleteJobItemsCommand.Transaction = transaction;
deleteJobItemsCommand.ExecuteNonQuery();
transaction.Commit();
}
catch (OperationCanceledException)
{
if (transaction != null)
{
transaction.Rollback();
}
throw;
}
catch (Exception e)
{
Logger.ErrorException("Failed to save record:", e);
if (transaction != null)
{
transaction.Rollback();
}
throw;
}
finally
{
if (transaction != null)
{
transaction.Dispose();
}
}
}
}
}
}
public QueryResult<SyncJob> GetJobs(SyncJobQuery query)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
CheckDisposed();
using (var connection = CreateConnection(true).Result)
{
using (var cmd = connection.CreateCommand())
{
cmd.CommandText = BaseJobSelectText;
var whereClauses = new List<string>();
if (query.Statuses.Length > 0)
{
var statuses = string.Join(",", query.Statuses.Select(i => "'" + i.ToString() + "'").ToArray());
whereClauses.Add(string.Format("Status in ({0})", statuses));
}
if (!string.IsNullOrWhiteSpace(query.TargetId))
{
whereClauses.Add("TargetId=@TargetId");
cmd.Parameters.Add(cmd, "@TargetId", DbType.String).Value = query.TargetId;
}
if (!string.IsNullOrWhiteSpace(query.ExcludeTargetIds))
{
var excludeIds = (query.ExcludeTargetIds ?? string.Empty).Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (excludeIds.Length == 1)
{
whereClauses.Add("TargetId<>@ExcludeTargetId");
cmd.Parameters.Add(cmd, "@ExcludeTargetId", DbType.String).Value = excludeIds[0];
}
else if (excludeIds.Length > 1)
{
whereClauses.Add("TargetId<>@ExcludeTargetId");
cmd.Parameters.Add(cmd, "@ExcludeTargetId", DbType.String).Value = excludeIds[0];
}
}
if (!string.IsNullOrWhiteSpace(query.UserId))
{
whereClauses.Add("UserId=@UserId");
cmd.Parameters.Add(cmd, "@UserId", DbType.String).Value = query.UserId;
}
if (query.SyncNewContent.HasValue)
{
whereClauses.Add("SyncNewContent=@SyncNewContent");
cmd.Parameters.Add(cmd, "@SyncNewContent", DbType.Boolean).Value = query.SyncNewContent.Value;
}
cmd.CommandText += " mainTable";
var whereTextWithoutPaging = whereClauses.Count == 0 ?
string.Empty :
" where " + string.Join(" AND ", whereClauses.ToArray());
var startIndex = query.StartIndex ?? 0;
if (startIndex > 0)
{
whereClauses.Add(string.Format("Id NOT IN (SELECT Id FROM SyncJobs ORDER BY (Select Max(DateLastModified) from SyncJobs where TargetId=mainTable.TargetId) DESC, DateLastModified DESC LIMIT {0})",
startIndex.ToString(_usCulture)));
}
if (whereClauses.Count > 0)
{
cmd.CommandText += " where " + string.Join(" AND ", whereClauses.ToArray());
}
cmd.CommandText += " ORDER BY (Select Max(DateLastModified) from SyncJobs where TargetId=mainTable.TargetId) DESC, DateLastModified DESC";
if (query.Limit.HasValue)
{
cmd.CommandText += " LIMIT " + query.Limit.Value.ToString(_usCulture);
}
cmd.CommandText += "; select count (Id) from SyncJobs" + whereTextWithoutPaging;
var list = new List<SyncJob>();
var count = 0;
using (var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess))
{
while (reader.Read())
{
list.Add(GetJob(reader));
}
if (reader.NextResult() && reader.Read())
{
count = reader.GetInt32(0);
}
}
return new QueryResult<SyncJob>()
{
Items = list.ToArray(),
TotalRecordCount = count
};
}
}
}
public SyncJobItem GetJobItem(string id)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentNullException("id");
}
CheckDisposed();
var guid = new Guid(id);
using (var connection = CreateConnection(true).Result)
{
using (var cmd = connection.CreateCommand())
{
cmd.CommandText = BaseJobItemSelectText + " where Id=@Id";
cmd.Parameters.Add(cmd, "@Id", DbType.Guid).Value = guid;
using (var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess | CommandBehavior.SingleResult | CommandBehavior.SingleRow))
{
if (reader.Read())
{
return GetJobItem(reader);
}
}
}
return null;
}
}
private QueryResult<T> GetJobItemReader<T>(SyncJobItemQuery query, string baseSelectText, Func<IDataReader, T> itemFactory)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
using (var connection = CreateConnection(true).Result)
{
using (var cmd = connection.CreateCommand())
{
cmd.CommandText = baseSelectText;
var whereClauses = new List<string>();
if (!string.IsNullOrWhiteSpace(query.JobId))
{
whereClauses.Add("JobId=@JobId");
cmd.Parameters.Add(cmd, "@JobId", DbType.String).Value = query.JobId;
}
if (!string.IsNullOrWhiteSpace(query.ItemId))
{
whereClauses.Add("ItemId=@ItemId");
cmd.Parameters.Add(cmd, "@ItemId", DbType.String).Value = query.ItemId;
}
if (!string.IsNullOrWhiteSpace(query.TargetId))
{
whereClauses.Add("TargetId=@TargetId");
cmd.Parameters.Add(cmd, "@TargetId", DbType.String).Value = query.TargetId;
}
if (query.Statuses.Length > 0)
{
var statuses = string.Join(",", query.Statuses.Select(i => "'" + i.ToString() + "'").ToArray());
whereClauses.Add(string.Format("Status in ({0})", statuses));
}
var whereTextWithoutPaging = whereClauses.Count == 0 ?
string.Empty :
" where " + string.Join(" AND ", whereClauses.ToArray());
var startIndex = query.StartIndex ?? 0;
if (startIndex > 0)
{
whereClauses.Add(string.Format("Id NOT IN (SELECT Id FROM SyncJobItems ORDER BY JobItemIndex, DateCreated LIMIT {0})",
startIndex.ToString(_usCulture)));
}
if (whereClauses.Count > 0)
{
cmd.CommandText += " where " + string.Join(" AND ", whereClauses.ToArray());
}
cmd.CommandText += " ORDER BY JobItemIndex, DateCreated";
if (query.Limit.HasValue)
{
cmd.CommandText += " LIMIT " + query.Limit.Value.ToString(_usCulture);
}
cmd.CommandText += "; select count (Id) from SyncJobItems" + whereTextWithoutPaging;
var list = new List<T>();
var count = 0;
using (var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess))
{
while (reader.Read())
{
list.Add(itemFactory(reader));
}
if (reader.NextResult() && reader.Read())
{
count = reader.GetInt32(0);
}
}
return new QueryResult<T>()
{
Items = list.ToArray(),
TotalRecordCount = count
};
}
}
}
public Dictionary<string, SyncedItemProgress> GetSyncedItemProgresses(SyncJobItemQuery query)
{
var result = new Dictionary<string, SyncedItemProgress>();
var now = DateTime.UtcNow;
using (var connection = CreateConnection(true).Result)
{
using (var cmd = connection.CreateCommand())
{
cmd.CommandText = "select ItemId,Status,Progress from SyncJobItems";
var whereClauses = new List<string>();
if (!string.IsNullOrWhiteSpace(query.TargetId))
{
whereClauses.Add("TargetId=@TargetId");
cmd.Parameters.Add(cmd, "@TargetId", DbType.String).Value = query.TargetId;
}
if (query.Statuses.Length > 0)
{
var statuses = string.Join(",", query.Statuses.Select(i => "'" + i.ToString() + "'").ToArray());
whereClauses.Add(string.Format("Status in ({0})", statuses));
}
if (whereClauses.Count > 0)
{
cmd.CommandText += " where " + string.Join(" AND ", whereClauses.ToArray());
}
cmd.CommandText += ";" + cmd.CommandText
.Replace("select ItemId,Status,Progress from SyncJobItems", "select ItemIds,Status,Progress from SyncJobs")
.Replace("'Synced'", "'Completed','CompletedWithError'");
//Logger.Debug(cmd.CommandText);
using (var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess))
{
LogQueryTime("GetSyncedItemProgresses", cmd, now);
while (reader.Read())
{
AddStatusResult(reader, result, false);
}
if (reader.NextResult())
{
while (reader.Read())
{
AddStatusResult(reader, result, true);
}
}
}
}
}
return result;
}
private void LogQueryTime(string methodName, IDbCommand cmd, DateTime startDate)
{
var elapsed = (DateTime.UtcNow - startDate).TotalMilliseconds;
var slowThreshold = 1000;
#if DEBUG
slowThreshold = 50;
#endif
if (elapsed >= slowThreshold)
{
Logger.Debug("{2} query time (slow): {0}ms. Query: {1}",
Convert.ToInt32(elapsed),
cmd.CommandText,
methodName);
}
else
{
//Logger.Debug("{2} query time: {0}ms. Query: {1}",
// Convert.ToInt32(elapsed),
// cmd.CommandText,
// methodName);
}
}
private void AddStatusResult(IDataReader reader, Dictionary<string, SyncedItemProgress> result, bool multipleIds)
{
if (reader.IsDBNull(0))
{
return;
}
var itemIds = new List<string>();
var ids = reader.GetString(0);
if (multipleIds)
{
itemIds = ids.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToList();
}
else
{
itemIds.Add(ids);
}
if (!reader.IsDBNull(1))
{
SyncJobItemStatus status;
var statusString = reader.GetString(1);
if (string.Equals(statusString, "Completed", StringComparison.OrdinalIgnoreCase) ||
string.Equals(statusString, "CompletedWithError", StringComparison.OrdinalIgnoreCase))
{
status = SyncJobItemStatus.Synced;
}
else
{
status = (SyncJobItemStatus)Enum.Parse(typeof(SyncJobItemStatus), statusString, true);
}
if (status == SyncJobItemStatus.Synced)
{
foreach (var itemId in itemIds)
{
result[itemId] = new SyncedItemProgress
{
Status = SyncJobItemStatus.Synced
};
}
}
else
{
double progress = reader.IsDBNull(2) ? 0.0 : reader.GetDouble(2);
foreach (var itemId in itemIds)
{
SyncedItemProgress currentStatus;
if (!result.TryGetValue(itemId, out currentStatus) || (currentStatus.Status != SyncJobItemStatus.Synced && progress >= currentStatus.Progress))
{
result[itemId] = new SyncedItemProgress
{
Status = status,
Progress = progress
};
}
}
}
}
}
public QueryResult<SyncJobItem> GetJobItems(SyncJobItemQuery query)
{
return GetJobItemReader(query, BaseJobItemSelectText, GetJobItem);
}
public Task Create(SyncJobItem jobItem)
{
return InsertOrUpdate(jobItem, true);
}
public Task Update(SyncJobItem jobItem)
{
return InsertOrUpdate(jobItem, false);
}
private async Task InsertOrUpdate(SyncJobItem jobItem, bool insert)
{
if (jobItem == null)
{
throw new ArgumentNullException("jobItem");
}
CheckDisposed();
using (var connection = await CreateConnection().ConfigureAwait(false))
{
using (var cmd = connection.CreateCommand())
{
if (insert)
{
cmd.CommandText = "insert into SyncJobItems (Id, ItemId, ItemName, MediaSourceId, JobId, TemporaryPath, OutputPath, Status, TargetId, DateCreated, Progress, AdditionalFiles, MediaSource, IsMarkedForRemoval, JobItemIndex, ItemDateModifiedTicks) values (@Id, @ItemId, @ItemName, @MediaSourceId, @JobId, @TemporaryPath, @OutputPath, @Status, @TargetId, @DateCreated, @Progress, @AdditionalFiles, @MediaSource, @IsMarkedForRemoval, @JobItemIndex, @ItemDateModifiedTicks)";
cmd.Parameters.Add(cmd, "@Id");
cmd.Parameters.Add(cmd, "@ItemId");
cmd.Parameters.Add(cmd, "@ItemName");
cmd.Parameters.Add(cmd, "@MediaSourceId");
cmd.Parameters.Add(cmd, "@JobId");
cmd.Parameters.Add(cmd, "@TemporaryPath");
cmd.Parameters.Add(cmd, "@OutputPath");
cmd.Parameters.Add(cmd, "@Status");
cmd.Parameters.Add(cmd, "@TargetId");
cmd.Parameters.Add(cmd, "@DateCreated");
cmd.Parameters.Add(cmd, "@Progress");
cmd.Parameters.Add(cmd, "@AdditionalFiles");
cmd.Parameters.Add(cmd, "@MediaSource");
cmd.Parameters.Add(cmd, "@IsMarkedForRemoval");
cmd.Parameters.Add(cmd, "@JobItemIndex");
cmd.Parameters.Add(cmd, "@ItemDateModifiedTicks");
}
else
{
// cmd
cmd.CommandText = "update SyncJobItems set ItemId=@ItemId,ItemName=@ItemName,MediaSourceId=@MediaSourceId,JobId=@JobId,TemporaryPath=@TemporaryPath,OutputPath=@OutputPath,Status=@Status,TargetId=@TargetId,DateCreated=@DateCreated,Progress=@Progress,AdditionalFiles=@AdditionalFiles,MediaSource=@MediaSource,IsMarkedForRemoval=@IsMarkedForRemoval,JobItemIndex=@JobItemIndex,ItemDateModifiedTicks=@ItemDateModifiedTicks where Id=@Id";
cmd.Parameters.Add(cmd, "@Id");
cmd.Parameters.Add(cmd, "@ItemId");
cmd.Parameters.Add(cmd, "@ItemName");
cmd.Parameters.Add(cmd, "@MediaSourceId");
cmd.Parameters.Add(cmd, "@JobId");
cmd.Parameters.Add(cmd, "@TemporaryPath");
cmd.Parameters.Add(cmd, "@OutputPath");
cmd.Parameters.Add(cmd, "@Status");
cmd.Parameters.Add(cmd, "@TargetId");
cmd.Parameters.Add(cmd, "@DateCreated");
cmd.Parameters.Add(cmd, "@Progress");
cmd.Parameters.Add(cmd, "@AdditionalFiles");
cmd.Parameters.Add(cmd, "@MediaSource");
cmd.Parameters.Add(cmd, "@IsMarkedForRemoval");
cmd.Parameters.Add(cmd, "@JobItemIndex");
cmd.Parameters.Add(cmd, "@ItemDateModifiedTicks");
}
IDbTransaction transaction = null;
try
{
transaction = connection.BeginTransaction();
var index = 0;
cmd.GetParameter(index++).Value = new Guid(jobItem.Id);
cmd.GetParameter(index++).Value = jobItem.ItemId;
cmd.GetParameter(index++).Value = jobItem.ItemName;
cmd.GetParameter(index++).Value = jobItem.MediaSourceId;
cmd.GetParameter(index++).Value = jobItem.JobId;
cmd.GetParameter(index++).Value = jobItem.TemporaryPath;
cmd.GetParameter(index++).Value = jobItem.OutputPath;
cmd.GetParameter(index++).Value = jobItem.Status.ToString();
cmd.GetParameter(index++).Value = jobItem.TargetId;
cmd.GetParameter(index++).Value = jobItem.DateCreated;
cmd.GetParameter(index++).Value = jobItem.Progress;
cmd.GetParameter(index++).Value = _json.SerializeToString(jobItem.AdditionalFiles);
cmd.GetParameter(index++).Value = jobItem.MediaSource == null ? null : _json.SerializeToString(jobItem.MediaSource);
cmd.GetParameter(index++).Value = jobItem.IsMarkedForRemoval;
cmd.GetParameter(index++).Value = jobItem.JobItemIndex;
cmd.GetParameter(index++).Value = jobItem.ItemDateModifiedTicks;
cmd.Transaction = transaction;
cmd.ExecuteNonQuery();
transaction.Commit();
}
catch (OperationCanceledException)
{
if (transaction != null)
{
transaction.Rollback();
}
throw;
}
catch (Exception e)
{
Logger.ErrorException("Failed to save record:", e);
if (transaction != null)
{
transaction.Rollback();
}
throw;
}
finally
{
if (transaction != null)
{
transaction.Dispose();
}
}
}
}
}
private SyncJobItem GetJobItem(IDataReader reader)
{
var info = new SyncJobItem
{
Id = reader.GetGuid(0).ToString("N"),
ItemId = reader.GetString(1)
};
if (!reader.IsDBNull(2))
{
info.ItemName = reader.GetString(2);
}
if (!reader.IsDBNull(3))
{
info.MediaSourceId = reader.GetString(3);
}
info.JobId = reader.GetString(4);
if (!reader.IsDBNull(5))
{
info.TemporaryPath = reader.GetString(5);
}
if (!reader.IsDBNull(6))
{
info.OutputPath = reader.GetString(6);
}
if (!reader.IsDBNull(7))
{
info.Status = (SyncJobItemStatus)Enum.Parse(typeof(SyncJobItemStatus), reader.GetString(7), true);
}
info.TargetId = reader.GetString(8);
info.DateCreated = reader.GetDateTime(9).ToUniversalTime();
if (!reader.IsDBNull(10))
{
info.Progress = reader.GetDouble(10);
}
if (!reader.IsDBNull(11))
{
var json = reader.GetString(11);
if (!string.IsNullOrWhiteSpace(json))
{
info.AdditionalFiles = _json.DeserializeFromString<List<ItemFileInfo>>(json);
}
}
if (!reader.IsDBNull(12))
{
var json = reader.GetString(12);
if (!string.IsNullOrWhiteSpace(json))
{
info.MediaSource = _json.DeserializeFromString<MediaSourceInfo>(json);
}
}
info.IsMarkedForRemoval = reader.GetBoolean(13);
info.JobItemIndex = reader.GetInt32(14);
if (!reader.IsDBNull(15))
{
info.ItemDateModifiedTicks = reader.GetInt64(15);
}
return info;
}
}
}

@ -87,7 +87,7 @@ namespace Emby.Server.Implementations.Activity
if (minDate.HasValue)
{
whereClauses.Add("DateCreated>=@DateCreated");
whereClauses.Add("DateCreated>=?");
paramList.Add(minDate.Value.ToDateTimeParamValue());
}

@ -1,7 +1,7 @@
using MediaBrowser.Controller;
using System;
namespace Emby.Server.Core.Browser
namespace Emby.Server.Implementations.Browser
{
/// <summary>
/// Class BrowserLauncher
@ -65,10 +65,8 @@ namespace Emby.Server.Core.Browser
{
}
catch (Exception ex)
catch (Exception)
{
Console.WriteLine("Error launching url: " + url);
Console.WriteLine(ex.Message);
}
}
}

@ -4,6 +4,7 @@ using System.Threading;
using System.Threading.Tasks;
using MediaBrowser.Model.Logging;
using SQLitePCL.pretty;
using System.Linq;
namespace Emby.Server.Implementations.Data
{
@ -120,21 +121,30 @@ namespace Emby.Server.Implementations.Data
}
protected void AddColumn(IDatabaseConnection connection, string table, string columnName, string type)
protected List<string> GetColumnNames(IDatabaseConnection connection, string table)
{
var list = new List<string>();
foreach (var row in connection.Query("PRAGMA table_info(" + table + ")"))
{
if (row[1].SQLiteType != SQLiteType.Null)
{
var name = row[1].ToString();
if (string.Equals(name, columnName, StringComparison.OrdinalIgnoreCase))
{
return;
}
list.Add(name);
}
}
return list;
}
protected void AddColumn(IDatabaseConnection connection, string table, string columnName, string type, List<string> existingColumnNames)
{
if (existingColumnNames.Contains(columnName, StringComparer.OrdinalIgnoreCase))
{
return;
}
connection.ExecuteAll(string.Join(";", new string[]
{
"alter table " + table,

@ -1,5 +1,4 @@
using MediaBrowser.Common.Progress;
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.Persistence;
@ -7,20 +6,13 @@ using MediaBrowser.Model.Entities;
using MediaBrowser.Model.Logging;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using MediaBrowser.Common.IO;
using MediaBrowser.Model.IO;
using MediaBrowser.Controller.Channels;
using MediaBrowser.Controller.Entities.Audio;
using MediaBrowser.Controller.IO;
using MediaBrowser.Controller.LiveTv;
using MediaBrowser.Controller.Net;
using MediaBrowser.Model.Globalization;
using MediaBrowser.Model.Tasks;
using Emby.Server.Implementations.ScheduledTasks;
namespace Emby.Server.Implementations.Data
{
@ -29,26 +21,14 @@ namespace Emby.Server.Implementations.Data
private readonly ILibraryManager _libraryManager;
private readonly IItemRepository _itemRepo;
private readonly ILogger _logger;
private readonly IServerConfigurationManager _config;
private readonly IFileSystem _fileSystem;
private readonly IHttpServer _httpServer;
private readonly ILocalizationManager _localization;
private readonly ITaskManager _taskManager;
public const int MigrationVersion = 23;
public static bool EnableUnavailableMessage = false;
const int LatestSchemaVersion = 109;
public CleanDatabaseScheduledTask(ILibraryManager libraryManager, IItemRepository itemRepo, ILogger logger, IServerConfigurationManager config, IFileSystem fileSystem, IHttpServer httpServer, ILocalizationManager localization, ITaskManager taskManager)
public CleanDatabaseScheduledTask(ILibraryManager libraryManager, IItemRepository itemRepo, ILogger logger, IFileSystem fileSystem)
{
_libraryManager = libraryManager;
_itemRepo = itemRepo;
_logger = logger;
_config = config;
_fileSystem = fileSystem;
_httpServer = httpServer;
_localization = localization;
_taskManager = taskManager;
}
public string Name
@ -68,8 +48,6 @@ namespace Emby.Server.Implementations.Data
public async Task Execute(CancellationToken cancellationToken, IProgress<double> progress)
{
OnProgress(0);
// Ensure these objects are lazy loaded.
// Without this there is a deadlock that will need to be investigated
var rootChildren = _libraryManager.RootFolder.Children.ToList();
@ -78,19 +56,7 @@ namespace Emby.Server.Implementations.Data
var innerProgress = new ActionableProgress<double>();
innerProgress.RegisterAction(p =>
{
double newPercentCommplete = .4 * p;
OnProgress(newPercentCommplete);
progress.Report(newPercentCommplete);
});
await UpdateToLatestSchema(cancellationToken, innerProgress).ConfigureAwait(false);
innerProgress = new ActionableProgress<double>();
innerProgress.RegisterAction(p =>
{
double newPercentCommplete = 40 + .05 * p;
OnProgress(newPercentCommplete);
double newPercentCommplete = .45 * p;
progress.Report(newPercentCommplete);
});
await CleanDeadItems(cancellationToken, innerProgress).ConfigureAwait(false);
@ -100,122 +66,12 @@ namespace Emby.Server.Implementations.Data
innerProgress.RegisterAction(p =>
{
double newPercentCommplete = 45 + .55 * p;
OnProgress(newPercentCommplete);
progress.Report(newPercentCommplete);
});
await CleanDeletedItems(cancellationToken, innerProgress).ConfigureAwait(false);
progress.Report(100);
await _itemRepo.UpdateInheritedValues(cancellationToken).ConfigureAwait(false);
if (_config.Configuration.MigrationVersion < MigrationVersion)
{
_config.Configuration.MigrationVersion = MigrationVersion;
_config.SaveConfiguration();
}
if (_config.Configuration.SchemaVersion < LatestSchemaVersion)
{
_config.Configuration.SchemaVersion = LatestSchemaVersion;
_config.SaveConfiguration();
}
if (EnableUnavailableMessage)
{
EnableUnavailableMessage = false;
_httpServer.GlobalResponse = null;
_taskManager.QueueScheduledTask<RefreshMediaLibraryTask>();
}
_taskManager.SuspendTriggers = false;
}
private void OnProgress(double newPercentCommplete)
{
if (EnableUnavailableMessage)
{
var html = "<!doctype html><html><head><title>Emby</title></head><body>";
var text = _localization.GetLocalizedString("DbUpgradeMessage");
html += string.Format(text, newPercentCommplete.ToString("N2", CultureInfo.InvariantCulture));
html += "<script>setTimeout(function(){window.location.reload(true);}, 5000);</script>";
html += "</body></html>";
_httpServer.GlobalResponse = html;
}
}
private async Task UpdateToLatestSchema(CancellationToken cancellationToken, IProgress<double> progress)
{
var itemIds = _libraryManager.GetItemIds(new InternalItemsQuery
{
IsCurrentSchema = false,
ExcludeItemTypes = new[] { typeof(LiveTvProgram).Name }
});
var numComplete = 0;
var numItems = itemIds.Count;
_logger.Debug("Upgrading schema for {0} items", numItems);
var list = new List<BaseItem>();
foreach (var itemId in itemIds)
{
cancellationToken.ThrowIfCancellationRequested();
if (itemId != Guid.Empty)
{
// Somehow some invalid data got into the db. It probably predates the boundary checking
var item = _libraryManager.GetItemById(itemId);
if (item != null)
{
list.Add(item);
}
}
if (list.Count >= 1000)
{
try
{
await _itemRepo.SaveItems(list, cancellationToken).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
_logger.ErrorException("Error saving item", ex);
}
list.Clear();
}
numComplete++;
double percent = numComplete;
percent /= numItems;
progress.Report(percent * 100);
}
if (list.Count > 0)
{
try
{
await _itemRepo.SaveItems(list, cancellationToken).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
_logger.ErrorException("Error saving item", ex);
}
}
progress.Report(100);
}
private async Task CleanDeadItems(CancellationToken cancellationToken, IProgress<double> progress)

@ -36,6 +36,7 @@
<Compile Include="Activity\ActivityManager.cs" />
<Compile Include="Activity\ActivityRepository.cs" />
<Compile Include="Branding\BrandingConfigurationFactory.cs" />
<Compile Include="Browser\BrowserLauncher.cs" />
<Compile Include="Channels\ChannelConfigurations.cs" />
<Compile Include="Channels\ChannelDynamicMediaSourceProvider.cs" />
<Compile Include="Channels\ChannelImageProvider.cs" />
@ -64,6 +65,7 @@
<Compile Include="EntryPoints\RecordingNotifier.cs" />
<Compile Include="EntryPoints\RefreshUsersMetadata.cs" />
<Compile Include="EntryPoints\ServerEventNotifier.cs" />
<Compile Include="EntryPoints\StartupWizard.cs" />
<Compile Include="EntryPoints\SystemEvents.cs" />
<Compile Include="EntryPoints\UdpServerEntryPoint.cs" />
<Compile Include="EntryPoints\UsageEntryPoint.cs" />
@ -174,6 +176,7 @@
<Compile Include="Localization\LocalizationManager.cs" />
<Compile Include="MediaEncoder\EncodingManager.cs" />
<Compile Include="Migrations\IVersionMigration.cs" />
<Compile Include="Migrations\UpdateLevelMigration.cs" />
<Compile Include="News\NewsEntryPoint.cs" />
<Compile Include="News\NewsService.cs" />
<Compile Include="Notifications\CoreNotificationTypes.cs" />
@ -258,6 +261,7 @@
<Compile Include="Sync\SyncManager.cs" />
<Compile Include="Sync\SyncNotificationEntryPoint.cs" />
<Compile Include="Sync\SyncRegistrationInfo.cs" />
<Compile Include="Sync\SyncRepository.cs" />
<Compile Include="Sync\TargetDataProvider.cs" />
<Compile Include="TV\SeriesPostScanTask.cs" />
<Compile Include="TV\TVSeriesManager.cs" />

@ -1,9 +1,9 @@
using MediaBrowser.Controller;
using Emby.Server.Implementations.Browser;
using MediaBrowser.Controller;
using MediaBrowser.Controller.Plugins;
using MediaBrowser.Model.Logging;
using Emby.Server.Core.Browser;
namespace Emby.Server.Core.EntryPoints
namespace Emby.Server.Implementations.EntryPoints
{
/// <summary>
/// Class StartupWizard

@ -74,7 +74,7 @@ namespace Emby.Server.Implementations.FileOrganization
return new[] {
// Every so often
new TaskTriggerInfo { Type = TaskTriggerInfo.TriggerInterval, IntervalTicks = TimeSpan.FromMinutes(5).Ticks}
new TaskTriggerInfo { Type = TaskTriggerInfo.TriggerInterval, IntervalTicks = TimeSpan.FromMinutes(15).Ticks}
};
}

@ -59,12 +59,13 @@ namespace Emby.Server.Implementations.HttpServer
private readonly IEnvironmentInfo _environment;
private readonly IStreamFactory _streamFactory;
private readonly Func<Type, Func<string, object>> _funcParseFn;
private readonly bool _enableDualModeSockets;
public HttpListenerHost(IServerApplicationHost applicationHost,
ILogger logger,
IServerConfigurationManager config,
string serviceName,
string defaultRedirectPath, INetworkManager networkManager, IMemoryStreamFactory memoryStreamProvider, ITextEncoding textEncoding, ISocketFactory socketFactory, ICryptoProvider cryptoProvider, IJsonSerializer jsonSerializer, IXmlSerializer xmlSerializer, IEnvironmentInfo environment, ICertificate certificate, IStreamFactory streamFactory, Func<Type, Func<string, object>> funcParseFn)
string defaultRedirectPath, INetworkManager networkManager, IMemoryStreamFactory memoryStreamProvider, ITextEncoding textEncoding, ISocketFactory socketFactory, ICryptoProvider cryptoProvider, IJsonSerializer jsonSerializer, IXmlSerializer xmlSerializer, IEnvironmentInfo environment, ICertificate certificate, IStreamFactory streamFactory, Func<Type, Func<string, object>> funcParseFn, bool enableDualModeSockets)
: base(serviceName)
{
_appHost = applicationHost;
@ -80,6 +81,7 @@ namespace Emby.Server.Implementations.HttpServer
_certificate = certificate;
_streamFactory = streamFactory;
_funcParseFn = funcParseFn;
_enableDualModeSockets = enableDualModeSockets;
_config = config;
_logger = logger;
@ -179,8 +181,6 @@ namespace Emby.Server.Implementations.HttpServer
private IHttpListener GetListener()
{
var enableDualMode = _environment.OperatingSystem == OperatingSystem.Windows;
return new WebSocketSharpListener(_logger,
_certificate,
_memoryStreamProvider,
@ -189,7 +189,7 @@ namespace Emby.Server.Implementations.HttpServer
_socketFactory,
_cryptoProvider,
_streamFactory,
enableDualMode,
_enableDualModeSockets,
GetRequest);
}

@ -2,16 +2,15 @@
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Emby.Common.Implementations.Updates;
using MediaBrowser.Common.Net;
using MediaBrowser.Common.Updates;
using MediaBrowser.Controller;
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Model.Logging;
using MediaBrowser.Model.Serialization;
using MediaBrowser.Model.Updates;
using Emby.Server.Implementations.Migrations;
namespace Emby.Server.Core.Migrations
namespace Emby.Server.Implementations.Migrations
{
public class UpdateLevelMigration : IVersionMigration
{

@ -40,7 +40,9 @@ namespace Emby.Server.Implementations.Security
connection.RunInTransaction(db =>
{
AddColumn(db, "AccessTokens", "AppVersion", "TEXT");
var existingColumnNames = GetColumnNames(db, "AccessTokens");
AddColumn(db, "AccessTokens", "AppVersion", "TEXT", existingColumnNames);
});
}
}

@ -0,0 +1,770 @@
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Emby.Server.Implementations.Data;
using MediaBrowser.Controller;
using MediaBrowser.Controller.Sync;
using MediaBrowser.Model.Dto;
using MediaBrowser.Model.Logging;
using MediaBrowser.Model.Querying;
using MediaBrowser.Model.Serialization;
using MediaBrowser.Model.Sync;
using SQLitePCL.pretty;
namespace Emby.Server.Implementations.Sync
{
public class SyncRepository : BaseSqliteRepository, ISyncRepository
{
private readonly CultureInfo _usCulture = new CultureInfo("en-US");
private readonly IJsonSerializer _json;
public SyncRepository(ILogger logger, IJsonSerializer json, IServerApplicationPaths appPaths)
: base(logger)
{
_json = json;
DbFilePath = Path.Combine(appPaths.DataPath, "sync14.db");
}
private class SyncSummary
{
public Dictionary<string, int> Items { get; set; }
public SyncSummary()
{
Items = new Dictionary<string, int>();
}
}
public void Initialize()
{
using (var connection = CreateConnection())
{
string[] queries = {
"create table if not exists SyncJobs (Id GUID PRIMARY KEY, TargetId TEXT NOT NULL, Name TEXT NOT NULL, Profile TEXT, Quality TEXT, Bitrate INT, Status TEXT NOT NULL, Progress FLOAT, UserId TEXT NOT NULL, ItemIds TEXT NOT NULL, Category TEXT, ParentId TEXT, UnwatchedOnly BIT, ItemLimit INT, SyncNewContent BIT, DateCreated DateTime, DateLastModified DateTime, ItemCount int)",
"create table if not exists SyncJobItems (Id GUID PRIMARY KEY, ItemId TEXT, ItemName TEXT, MediaSourceId TEXT, JobId TEXT, TemporaryPath TEXT, OutputPath TEXT, Status TEXT, TargetId TEXT, DateCreated DateTime, Progress FLOAT, AdditionalFiles TEXT, MediaSource TEXT, IsMarkedForRemoval BIT, JobItemIndex INT, ItemDateModifiedTicks BIGINT)",
"drop index if exists idx_SyncJobItems2",
"drop index if exists idx_SyncJobItems3",
"drop index if exists idx_SyncJobs1",
"drop index if exists idx_SyncJobs",
"drop index if exists idx_SyncJobItems1",
"create index if not exists idx_SyncJobItems4 on SyncJobItems(TargetId,ItemId,Status,Progress,DateCreated)",
"create index if not exists idx_SyncJobItems5 on SyncJobItems(TargetId,Status,ItemId,Progress)",
"create index if not exists idx_SyncJobs2 on SyncJobs(TargetId,Status,ItemIds,Progress)",
"pragma shrink_memory"
};
connection.RunQueries(queries);
connection.RunInTransaction(db =>
{
var existingColumnNames = GetColumnNames(db, "SyncJobs");
AddColumn(db, "SyncJobs", "Profile", "TEXT", existingColumnNames);
AddColumn(db, "SyncJobs", "Bitrate", "INT", existingColumnNames);
existingColumnNames = GetColumnNames(db, "SyncJobItems");
AddColumn(db, "SyncJobItems", "ItemDateModifiedTicks", "BIGINT", existingColumnNames);
});
}
}
private const string BaseJobSelectText = "select Id, TargetId, Name, Profile, Quality, Bitrate, Status, Progress, UserId, ItemIds, Category, ParentId, UnwatchedOnly, ItemLimit, SyncNewContent, DateCreated, DateLastModified, ItemCount from SyncJobs";
private const string BaseJobItemSelectText = "select Id, ItemId, ItemName, MediaSourceId, JobId, TemporaryPath, OutputPath, Status, TargetId, DateCreated, Progress, AdditionalFiles, MediaSource, IsMarkedForRemoval, JobItemIndex, ItemDateModifiedTicks from SyncJobItems";
public SyncJob GetJob(string id)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentNullException("id");
}
CheckDisposed();
var guid = new Guid(id);
if (guid == Guid.Empty)
{
throw new ArgumentNullException("id");
}
lock (WriteLock)
{
using (var connection = CreateConnection(true))
{
var commandText = BaseJobSelectText + " where Id=?";
var paramList = new List<object>();
paramList.Add(guid.ToGuidParamValue());
foreach (var row in connection.Query(commandText, paramList.ToArray()))
{
return GetJob(row);
}
return null;
}
}
}
private SyncJob GetJob(IReadOnlyList<IResultSetValue> reader)
{
var info = new SyncJob
{
Id = reader[0].ReadGuid().ToString("N"),
TargetId = reader[1].ToString(),
Name = reader[2].ToString()
};
if (reader[3].SQLiteType != SQLiteType.Null)
{
info.Profile = reader[3].ToString();
}
if (reader[4].SQLiteType != SQLiteType.Null)
{
info.Quality = reader[4].ToString();
}
if (reader[5].SQLiteType != SQLiteType.Null)
{
info.Bitrate = reader[5].ToInt();
}
if (reader[6].SQLiteType != SQLiteType.Null)
{
info.Status = (SyncJobStatus)Enum.Parse(typeof(SyncJobStatus), reader[6].ToString(), true);
}
if (reader[7].SQLiteType != SQLiteType.Null)
{
info.Progress = reader[7].ToDouble();
}
if (reader[8].SQLiteType != SQLiteType.Null)
{
info.UserId = reader[8].ToString();
}
if (reader[9].SQLiteType != SQLiteType.Null)
{
info.RequestedItemIds = reader[9].ToString().Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToList();
}
if (reader[10].SQLiteType != SQLiteType.Null)
{
info.Category = (SyncCategory)Enum.Parse(typeof(SyncCategory), reader[10].ToString(), true);
}
if (reader[11].SQLiteType != SQLiteType.Null)
{
info.ParentId = reader[11].ToString();
}
if (reader[12].SQLiteType != SQLiteType.Null)
{
info.UnwatchedOnly = reader[12].ToBool();
}
if (reader[13].SQLiteType != SQLiteType.Null)
{
info.ItemLimit = reader[13].ToInt();
}
info.SyncNewContent = reader[14].ToBool();
info.DateCreated = reader[15].ReadDateTime();
info.DateLastModified = reader[16].ReadDateTime();
info.ItemCount = reader[17].ToInt();
return info;
}
public Task Create(SyncJob job)
{
return InsertOrUpdate(job, true);
}
public Task Update(SyncJob job)
{
return InsertOrUpdate(job, false);
}
private async Task InsertOrUpdate(SyncJob job, bool insert)
{
if (job == null)
{
throw new ArgumentNullException("job");
}
CheckDisposed();
lock (WriteLock)
{
using (var connection = CreateConnection())
{
string commandText;
var paramList = new List<object>();
if (insert)
{
commandText = "insert into SyncJobs (Id, TargetId, Name, Profile, Quality, Bitrate, Status, Progress, UserId, ItemIds, Category, ParentId, UnwatchedOnly, ItemLimit, SyncNewContent, DateCreated, DateLastModified, ItemCount) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
}
else
{
commandText = "update SyncJobs set TargetId=?,Name=?,Profile=?,Quality=?,Bitrate=?,Status=?,Progress=?,UserId=?,ItemIds=?,Category=?,ParentId=?,UnwatchedOnly=?,ItemLimit=?,SyncNewContent=?,DateCreated=?,DateLastModified=?,ItemCount=? where Id=?";
}
paramList.Add(job.Id.ToGuidParamValue());
paramList.Add(job.TargetId);
paramList.Add(job.Name);
paramList.Add(job.Profile);
paramList.Add(job.Quality);
paramList.Add(job.Bitrate);
paramList.Add(job.Status.ToString());
paramList.Add(job.Progress);
paramList.Add(job.UserId);
paramList.Add(string.Join(",", job.RequestedItemIds.ToArray()));
paramList.Add(job.Category);
paramList.Add(job.ParentId);
paramList.Add(job.UnwatchedOnly);
paramList.Add(job.ItemLimit);
paramList.Add(job.SyncNewContent);
paramList.Add(job.DateCreated.ToDateTimeParamValue());
paramList.Add(job.DateLastModified.ToDateTimeParamValue());
paramList.Add(job.ItemCount);
connection.RunInTransaction(conn =>
{
conn.Execute(commandText, paramList.ToArray());
});
}
}
}
public async Task DeleteJob(string id)
{
if (string.IsNullOrWhiteSpace(id))
{
throw new ArgumentNullException("id");
}
CheckDisposed();
lock (WriteLock)
{
using (var connection = CreateConnection())
{
connection.RunInTransaction(conn =>
{
conn.Execute("delete from SyncJobs where Id=?", id.ToGuidParamValue());
conn.Execute("delete from SyncJobItems where JobId=?", id);
});
}
}
}
public QueryResult<SyncJob> GetJobs(SyncJobQuery query)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
CheckDisposed();
lock (WriteLock)
{
using (var connection = CreateConnection(true))
{
var commandText = BaseJobSelectText;
var paramList = new List<object>();
var whereClauses = new List<string>();
if (query.Statuses.Length > 0)
{
var statuses = string.Join(",", query.Statuses.Select(i => "'" + i.ToString() + "'").ToArray());
whereClauses.Add(string.Format("Status in ({0})", statuses));
}
if (!string.IsNullOrWhiteSpace(query.TargetId))
{
whereClauses.Add("TargetId=?");
paramList.Add(query.TargetId);
}
if (!string.IsNullOrWhiteSpace(query.ExcludeTargetIds))
{
var excludeIds = (query.ExcludeTargetIds ?? string.Empty).Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (excludeIds.Length == 1)
{
whereClauses.Add("TargetId<>?");
paramList.Add(excludeIds[0]);
}
else if (excludeIds.Length > 1)
{
whereClauses.Add("TargetId<>?");
paramList.Add(excludeIds[0]);
}
}
if (!string.IsNullOrWhiteSpace(query.UserId))
{
whereClauses.Add("UserId=?");
paramList.Add(query.UserId);
}
if (query.SyncNewContent.HasValue)
{
whereClauses.Add("SyncNewContent=?");
paramList.Add(query.SyncNewContent.Value);
}
commandText += " mainTable";
var whereTextWithoutPaging = whereClauses.Count == 0 ?
string.Empty :
" where " + string.Join(" AND ", whereClauses.ToArray());
var startIndex = query.StartIndex ?? 0;
if (startIndex > 0)
{
whereClauses.Add(string.Format("Id NOT IN (SELECT Id FROM SyncJobs ORDER BY (Select Max(DateLastModified) from SyncJobs where TargetId=mainTable.TargetId) DESC, DateLastModified DESC LIMIT {0})",
startIndex.ToString(_usCulture)));
}
if (whereClauses.Count > 0)
{
commandText += " where " + string.Join(" AND ", whereClauses.ToArray());
}
commandText += " ORDER BY (Select Max(DateLastModified) from SyncJobs where TargetId=mainTable.TargetId) DESC, DateLastModified DESC";
if (query.Limit.HasValue)
{
commandText += " LIMIT " + query.Limit.Value.ToString(_usCulture);
}
var list = new List<SyncJob>();
var count = connection.Query("select count (Id) from SyncJobs" + whereTextWithoutPaging, paramList.ToArray())
.SelectScalarInt()
.First();
foreach (var row in connection.Query(commandText, paramList.ToArray()))
{
list.Add(GetJob(row));
}
return new QueryResult<SyncJob>()
{
Items = list.ToArray(),
TotalRecordCount = count
};
}
}
}
public SyncJobItem GetJobItem(string id)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentNullException("id");
}
CheckDisposed();
lock (WriteLock)
{
var guid = new Guid(id);
using (var connection = CreateConnection(true))
{
var commandText = BaseJobItemSelectText + " where Id=?";
var paramList = new List<object>();
paramList.Add(guid.ToGuidParamValue());
foreach (var row in connection.Query(commandText, paramList.ToArray()))
{
return GetJobItem(row);
}
return null;
}
}
}
private QueryResult<T> GetJobItemReader<T>(SyncJobItemQuery query, string baseSelectText, Func<IReadOnlyList<IResultSetValue>, T> itemFactory)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
lock (WriteLock)
{
using (var connection = CreateConnection(true))
{
var commandText = baseSelectText;
var paramList = new List<object>();
var whereClauses = new List<string>();
if (!string.IsNullOrWhiteSpace(query.JobId))
{
whereClauses.Add("JobId=?");
paramList.Add(query.JobId);
}
if (!string.IsNullOrWhiteSpace(query.ItemId))
{
whereClauses.Add("ItemId=?");
paramList.Add(query.ItemId);
}
if (!string.IsNullOrWhiteSpace(query.TargetId))
{
whereClauses.Add("TargetId=?");
paramList.Add(query.TargetId);
}
if (query.Statuses.Length > 0)
{
var statuses = string.Join(",", query.Statuses.Select(i => "'" + i.ToString() + "'").ToArray());
whereClauses.Add(string.Format("Status in ({0})", statuses));
}
var whereTextWithoutPaging = whereClauses.Count == 0 ?
string.Empty :
" where " + string.Join(" AND ", whereClauses.ToArray());
var startIndex = query.StartIndex ?? 0;
if (startIndex > 0)
{
whereClauses.Add(string.Format("Id NOT IN (SELECT Id FROM SyncJobItems ORDER BY JobItemIndex, DateCreated LIMIT {0})",
startIndex.ToString(_usCulture)));
}
if (whereClauses.Count > 0)
{
commandText += " where " + string.Join(" AND ", whereClauses.ToArray());
}
commandText += " ORDER BY JobItemIndex, DateCreated";
if (query.Limit.HasValue)
{
commandText += " LIMIT " + query.Limit.Value.ToString(_usCulture);
}
var list = new List<T>();
var count = connection.Query("select count (Id) from SyncJobItems" + whereTextWithoutPaging, paramList.ToArray())
.SelectScalarInt()
.First();
foreach (var row in connection.Query(commandText, paramList.ToArray()))
{
list.Add(itemFactory(row));
}
return new QueryResult<T>()
{
Items = list.ToArray(),
TotalRecordCount = count
};
}
}
}
public Dictionary<string, SyncedItemProgress> GetSyncedItemProgresses(SyncJobItemQuery query)
{
var result = new Dictionary<string, SyncedItemProgress>();
var now = DateTime.UtcNow;
lock (WriteLock)
{
using (var connection = CreateConnection(true))
{
var commandText = "select ItemId,Status,Progress from SyncJobItems";
var whereClauses = new List<string>();
var paramList = new List<object>();
if (!string.IsNullOrWhiteSpace(query.TargetId))
{
whereClauses.Add("TargetId=?");
paramList.Add(query.TargetId);
}
if (query.Statuses.Length > 0)
{
var statuses = string.Join(",", query.Statuses.Select(i => "'" + i.ToString() + "'").ToArray());
whereClauses.Add(string.Format("Status in ({0})", statuses));
}
if (whereClauses.Count > 0)
{
commandText += " where " + string.Join(" AND ", whereClauses.ToArray());
}
foreach (var row in connection.Query(commandText, paramList.ToArray()))
{
AddStatusResult(row, result, false);
}
LogQueryTime("GetSyncedItemProgresses", commandText, now);
commandText = commandText
.Replace("select ItemId,Status,Progress from SyncJobItems", "select ItemIds,Status,Progress from SyncJobs")
.Replace("'Synced'", "'Completed','CompletedWithError'");
now = DateTime.UtcNow;
foreach (var row in connection.Query(commandText, paramList.ToArray()))
{
AddStatusResult(row, result, true);
}
LogQueryTime("GetSyncedItemProgresses", commandText, now);
}
}
return result;
}
private void LogQueryTime(string methodName, string commandText, DateTime startDate)
{
var elapsed = (DateTime.UtcNow - startDate).TotalMilliseconds;
var slowThreshold = 1000;
#if DEBUG
slowThreshold = 50;
#endif
if (elapsed >= slowThreshold)
{
Logger.Debug("{2} query time (slow): {0}ms. Query: {1}",
Convert.ToInt32(elapsed),
commandText,
methodName);
}
else
{
//Logger.Debug("{2} query time: {0}ms. Query: {1}",
// Convert.ToInt32(elapsed),
// cmd.CommandText,
// methodName);
}
}
private void AddStatusResult(IReadOnlyList<IResultSetValue> reader, Dictionary<string, SyncedItemProgress> result, bool multipleIds)
{
if (reader[0].SQLiteType == SQLiteType.Null)
{
return;
}
var itemIds = new List<string>();
var ids = reader[0].ToString();
if (multipleIds)
{
itemIds = ids.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToList();
}
else
{
itemIds.Add(ids);
}
if (reader[1].SQLiteType != SQLiteType.Null)
{
SyncJobItemStatus status;
var statusString = reader[1].ToString();
if (string.Equals(statusString, "Completed", StringComparison.OrdinalIgnoreCase) ||
string.Equals(statusString, "CompletedWithError", StringComparison.OrdinalIgnoreCase))
{
status = SyncJobItemStatus.Synced;
}
else
{
status = (SyncJobItemStatus)Enum.Parse(typeof(SyncJobItemStatus), statusString, true);
}
if (status == SyncJobItemStatus.Synced)
{
foreach (var itemId in itemIds)
{
result[itemId] = new SyncedItemProgress
{
Status = SyncJobItemStatus.Synced
};
}
}
else
{
double progress = reader[2].SQLiteType == SQLiteType.Null ? 0.0 : reader[2].ToDouble();
foreach (var itemId in itemIds)
{
SyncedItemProgress currentStatus;
if (!result.TryGetValue(itemId, out currentStatus) || (currentStatus.Status != SyncJobItemStatus.Synced && progress >= currentStatus.Progress))
{
result[itemId] = new SyncedItemProgress
{
Status = status,
Progress = progress
};
}
}
}
}
}
public QueryResult<SyncJobItem> GetJobItems(SyncJobItemQuery query)
{
return GetJobItemReader(query, BaseJobItemSelectText, GetJobItem);
}
public Task Create(SyncJobItem jobItem)
{
return InsertOrUpdate(jobItem, true);
}
public Task Update(SyncJobItem jobItem)
{
return InsertOrUpdate(jobItem, false);
}
private async Task InsertOrUpdate(SyncJobItem jobItem, bool insert)
{
if (jobItem == null)
{
throw new ArgumentNullException("jobItem");
}
CheckDisposed();
lock (WriteLock)
{
using (var connection = CreateConnection())
{
string commandText;
if (insert)
{
commandText = "insert into SyncJobItems (Id, ItemId, ItemName, MediaSourceId, JobId, TemporaryPath, OutputPath, Status, TargetId, DateCreated, Progress, AdditionalFiles, MediaSource, IsMarkedForRemoval, JobItemIndex, ItemDateModifiedTicks) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
}
else
{
// cmd
commandText = "update SyncJobItems set ItemId=?,ItemName=?,MediaSourceId=?,JobId=?,TemporaryPath=?,OutputPath=?,Status=?,TargetId=?,DateCreated=?,Progress=?,AdditionalFiles=?,MediaSource=?,IsMarkedForRemoval=?,JobItemIndex=?,ItemDateModifiedTicks=? where Id=?";
}
var paramList = new List<object>();
paramList.Add(jobItem.Id.ToGuidParamValue());
paramList.Add(jobItem.ItemId);
paramList.Add(jobItem.ItemName);
paramList.Add(jobItem.MediaSourceId);
paramList.Add(jobItem.JobId);
paramList.Add(jobItem.TemporaryPath);
paramList.Add(jobItem.OutputPath);
paramList.Add(jobItem.Status.ToString());
paramList.Add(jobItem.TargetId);
paramList.Add(jobItem.DateCreated.ToDateTimeParamValue());
paramList.Add(jobItem.Progress);
paramList.Add(_json.SerializeToString(jobItem.AdditionalFiles));
paramList.Add(jobItem.MediaSource == null ? null : _json.SerializeToString(jobItem.MediaSource));
paramList.Add(jobItem.IsMarkedForRemoval);
paramList.Add(jobItem.JobItemIndex);
paramList.Add(jobItem.ItemDateModifiedTicks);
connection.RunInTransaction(conn =>
{
conn.Execute(commandText, paramList.ToArray());
});
}
}
}
private SyncJobItem GetJobItem(IReadOnlyList<IResultSetValue> reader)
{
var info = new SyncJobItem
{
Id = reader[0].ReadGuid().ToString("N"),
ItemId = reader[1].ToString()
};
if (reader[2].SQLiteType != SQLiteType.Null)
{
info.ItemName = reader[2].ToString();
}
if (reader[3].SQLiteType != SQLiteType.Null)
{
info.MediaSourceId = reader[3].ToString();
}
info.JobId = reader[4].ToString();
if (reader[5].SQLiteType != SQLiteType.Null)
{
info.TemporaryPath = reader[5].ToString();
}
if (reader[6].SQLiteType != SQLiteType.Null)
{
info.OutputPath = reader[6].ToString();
}
if (reader[7].SQLiteType != SQLiteType.Null)
{
info.Status = (SyncJobItemStatus)Enum.Parse(typeof(SyncJobItemStatus), reader[7].ToString(), true);
}
info.TargetId = reader[8].ToString();
info.DateCreated = reader[9].ReadDateTime();
if (reader[10].SQLiteType != SQLiteType.Null)
{
info.Progress = reader[10].ToDouble();
}
if (reader[11].SQLiteType != SQLiteType.Null)
{
var json = reader[11].ToString();
if (!string.IsNullOrWhiteSpace(json))
{
info.AdditionalFiles = _json.DeserializeFromString<List<ItemFileInfo>>(json);
}
}
if (reader[12].SQLiteType != SQLiteType.Null)
{
var json = reader[12].ToString();
if (!string.IsNullOrWhiteSpace(json))
{
info.MediaSource = _json.DeserializeFromString<MediaSourceInfo>(json);
}
}
info.IsMarkedForRemoval = reader[13].ToBool();
info.JobItemIndex = reader[14].ToInt();
if (reader[15].SQLiteType != SQLiteType.Null)
{
info.ItemDateModifiedTicks = reader[15].ToInt64();
}
return info;
}
}
}

@ -148,10 +148,6 @@ namespace Emby.Server.Implementations.TV
private string GetUniqueSeriesKey(BaseItem series)
{
if (_config.Configuration.SchemaVersion < 97)
{
return series.Id.ToString("N");
}
return series.GetPresentationUniqueKey();
}

@ -115,7 +115,6 @@ namespace MediaBrowser.Api
config.EnableStandaloneMusicKeys = true;
config.EnableCaseSensitiveItemIds = true;
config.EnableFolderView = true;
config.SchemaVersion = 109;
config.EnableSimpleArtistDetection = true;
config.SkipDeserializationForBasicTypes = true;
config.SkipDeserializationForPrograms = true;

@ -70,6 +70,7 @@
<Compile Include="Security\IRequiresRegistration.cs" />
<Compile Include="Security\ISecurityManager.cs" />
<Compile Include="Security\PaymentRequiredException.cs" />
<Compile Include="Updates\GithubUpdater.cs" />
<Compile Include="Updates\IInstallationManager.cs" />
<Compile Include="Updates\InstallationEventArgs.cs" />
<Compile Include="Updates\InstallationFailedEventArgs.cs" />

@ -8,7 +8,7 @@ using MediaBrowser.Common.Net;
using MediaBrowser.Model.Serialization;
using MediaBrowser.Model.Updates;
namespace Emby.Common.Implementations.Updates
namespace MediaBrowser.Common.Updates
{
public class GithubUpdater
{

@ -123,7 +123,6 @@ namespace MediaBrowser.Controller.Entities
public int? MinParentalRating { get; set; }
public int? MaxParentalRating { get; set; }
public bool? IsCurrentSchema { get; set; }
public bool? HasDeadParentId { get; set; }
public bool? IsOffline { get; set; }
public bool? IsVirtualItem { get; set; }

@ -126,10 +126,6 @@ namespace MediaBrowser.Controller.Entities.TV
private static string GetUniqueSeriesKey(BaseItem series)
{
if (ConfigurationManager.Configuration.SchemaVersion < 97)
{
return series.Id.ToString("N");
}
return series.GetPresentationUniqueKey();
}

@ -192,9 +192,6 @@ namespace MediaBrowser.Model.Configuration
public int SharingExpirationDays { get; set; }
public string[] Migrations { get; set; }
public int MigrationVersion { get; set; }
public int SchemaVersion { get; set; }
public int SqliteCacheSize { get; set; }
@ -218,7 +215,6 @@ namespace MediaBrowser.Model.Configuration
public ServerConfiguration()
{
LocalNetworkAddresses = new string[] { };
Migrations = new string[] { };
CodecsUsed = new string[] { };
SqliteCacheSize = 0;
ImageExtractionTimeoutMs = 0;

@ -74,7 +74,5 @@ namespace MediaBrowser.Model.Tasks
event EventHandler<GenericEventArgs<IScheduledTaskWorker>> TaskExecuting;
event EventHandler<TaskCompletionEventArgs> TaskCompleted;
bool SuspendTriggers { get; set; }
}
}

@ -92,6 +92,32 @@ namespace MediaBrowser.Server.Mono
MainClass.Shutdown();
}
protected override bool SupportsDualModeSockets
{
get
{
return GetMonoVersion() >= new Version(4, 6);
}
}
private static Version GetMonoVersion()
{
Type type = Type.GetType("Mono.Runtime");
if (type != null)
{
MethodInfo displayName = type.GetTypeInfo().GetMethod("GetDisplayName", BindingFlags.NonPublic | BindingFlags.Static);
var displayNameValue = displayName.Invoke(null, null).ToString().Trim().Split(' ')[0];
Version version;
if (Version.TryParse(displayNameValue, out version))
{
return version;
}
}
return new Version(1, 0);
}
protected override void AuthorizeServer()
{
throw new NotImplementedException();

@ -6,7 +6,8 @@ namespace MediaBrowser.Server.Mono.Native
{
public class MonoFileSystem : ManagedFileSystem
{
public MonoFileSystem(ILogger logger, bool supportsAsyncFileStreams, bool enableManagedInvalidFileNameChars) : base(logger, supportsAsyncFileStreams, enableManagedInvalidFileNameChars, false)
public MonoFileSystem(ILogger logger, bool supportsAsyncFileStreams, bool enableManagedInvalidFileNameChars)
: base(logger, supportsAsyncFileStreams, enableManagedInvalidFileNameChars, true)
{
}

@ -23,8 +23,8 @@ using Emby.Common.Implementations.Logging;
using Emby.Common.Implementations.Networking;
using Emby.Common.Implementations.Security;
using Emby.Server.Core;
using Emby.Server.Core.Browser;
using Emby.Server.Implementations;
using Emby.Server.Implementations.Browser;
using Emby.Server.Implementations.IO;
using ImageMagickSharp;
using MediaBrowser.Common.Net;

@ -4,7 +4,7 @@ using MediaBrowser.Model.Logging;
using System;
using System.ComponentModel;
using System.Windows.Forms;
using Emby.Server.Core.Browser;
using Emby.Server.Implementations.Browser;
using MediaBrowser.Model.Globalization;
namespace MediaBrowser.ServerApplication

@ -117,6 +117,14 @@ namespace MediaBrowser.ServerApplication
}
}
protected override bool SupportsDualModeSockets
{
get
{
return true;
}
}
public override void LaunchUrl(string url)
{
var process = new Process
@ -137,6 +145,7 @@ namespace MediaBrowser.ServerApplication
}
catch (Exception ex)
{
Console.WriteLine("Error launching url: {0}", url);
Logger.ErrorException("Error launching url: {0}", ex, url);
throw;

Loading…
Cancel
Save