/// <summary>
/// Speichert diesen Auftrag ab.
/// </summary>
/// <param name="target">Der Pfad zu einem Zielverzeichnis.</param>
/// <returns>Gesetzt, wenn der Speichervorgang erfolgreich war. <i>null</i> wird
/// gemeldet, wenn diesem Auftrag keine Datei zugeordnet ist.</returns>
public bool?Save(DirectoryInfo target)
{
// Get the file
var file = GetFileName(target);
if (file == null)
{
return(null);
}
// Be safe
try
{
// Process
SerializationTools.Save(this, file);
}
catch (Exception e)
{
// Report
VCRServer.Log(e);
// Done
return(false);
}
// Done
return(true);
}
/// <summary>
/// Erzeugt eine neue Laufzeitumgebung und bindet diese an einen lokalen
/// TCP/IP Port.
/// </summary>
/// <remarks>
/// Als virtuelles Verzeichnis wird <i>/VCR.NET</i> verwendet. Dieses wird
/// physikalisch an das Verzeichnis gebunden, dass der aktuellen Anwendung
/// übergeordnet ist. Es empfiehlt sich, die Anwendung in einem Unterverzeichnis
/// <i>bin</i> unterzubringen.
/// </remarks>
/// <exception cref="InvalidOperationException">Es wurde bereits eine Laufzeitumgebung
/// angelegt.</exception>
public void Start()
{
// Report
Tools.ExtendedLogging("Starting Web Server");
// Already running
if (m_endPoints.Count > 0)
{
return;
}
// Create
m_endPoints.Add(new PrimaryEndPoint(m_server));
// Check the application directory
var appDir = new DirectoryInfo(Path.Combine(Tools.ApplicationDirectory.Parent.FullName, ApplicationRoot));
if (appDir.Exists)
{
foreach (var app in appDir.GetDirectories())
{
m_endPoints.Add(new ExtensionEndPoint(app.Name, Path.Combine(ApplicationRoot, app.Name)));
}
}
// Report
Tools.ExtendedLogging("Listener is up and running");
// Report
VCRServer.Log(LoggingLevel.Full, Properties.Resources.WebServerStarted);
}
/// <summary>
/// Aktualisiert die Programmzeitschrift mit neuen Daten.
/// </summary>
/// <param name="entries">Die neuen Daten.</param>
internal void UpdateGuide(ProgramGuideEntries entries)
{
// Report
Tools.ExtendedLogging("Program Guide of {0} will be updated", ProfileName);
// Did collection
LastUpdateTime = DateTime.UtcNow;
// Try to load resulting file
try
{
// Create brand new
var newData = m_Events.Clone();
// Merge new
newData.Merge(entries);
// Cleanup
newData.DiscardOld();
// Save
SerializationTools.Save(newData, ProgramGuideFile, Encoding.UTF8);
// Use it
m_Events = newData;
// Report
Tools.ExtendedLogging("Now using new Program Guide");
}
catch (Exception e)
{
// Report
VCRServer.Log(LoggingLevel.Errors, Properties.Resources.EPGMergeFailed, e);
}
}
/// <summary>
/// Löschte diesen Auftrag.
/// </summary>
/// <param name="target">Der Pfad zu einem Zielverzeichnis.</param>
/// <returns>Gesetzt, wenn der Löschvorgang erfolgreich war. <i>null</i> wird gemeldet,
/// wenn die Datei nicht existierte.</returns>
public bool?Delete(DirectoryInfo target)
{
// Get the file
var file = GetFileName(target);
if (file == null)
{
return(null);
}
if (!file.Exists)
{
return(null);
}
// Be safe
try
{
// Process
file.Delete();
}
catch (Exception e)
{
// Report error
VCRServer.Log(e);
// Failed
return(false);
}
// Did it
return(true);
}
/// <summary>
/// Erstellt eine Verwaltung der Anwendung.
/// </summary>
/// <param name="server">Der Dienst selbst.</param>
public PrimaryEndPoint(VCRServer server)
: base("VCR.NET", string.Empty)
{
m_server = server;
Start();
}
/// <summary>
/// Verbindet die ASP.NET Laufzeitumgebung des aktuellen virtuellen Verzeichnisses
/// mit der aktiven VCR.NET Instanz.
/// </summary>
/// <param name="server">Die aktive VCR.NET Instanz.</param>
public void SetServer(VCRServer server)
{
// Activate configuration from main domain
VCRConfiguration.Register(server.Configuration);
// Add to permanent cache
_VCRServer = server;
}
/// <summary>
/// Beendet die ASP.NET Laufzeitumgebung.
/// </summary>
/// <remarks>
/// Der Aufruf kehrt erst wieder zurück, wenn alle ausstehenden Anfragen bearbeitet
/// wurden. Neue Anfragen werden nicht angenommen.
/// </remarks>
public override void Stop()
{
// Reset
_VCRServer = null;
// Forward
base.Stop();
}
/// <summary>
/// Erzeugt eine neue Verwaltungsinstanz.
/// </summary>
/// <param name="jobs">Die zugehörige Auftragsverwaltung.</param>
/// <param name="profileName">Der Name des verwalteten DVB.NET Geräteprofils.</param>
public ProgramGuideManager(JobManager jobs, string profileName)
{
// Remember
ProfileName = profileName;
JobManager = jobs;
// Calculate file
ProgramGuideFile = new FileInfo(Path.Combine(JobManager.CollectorDirectory.FullName, $"EPGData for {ProfileName}.xml"));
// See if profile has it's own program guide
if (!HasProgramGuide)
{
return;
}
// Report
Tools.ExtendedLogging("Looking for Program Guide of {0}", ProfileName);
// No such file - start empty
if (!ProgramGuideFile.Exists)
{
return;
}
// Process
var events = SerializationTools.Load <ProgramGuideEntries>(ProgramGuideFile);
if (events != null)
{
// Use it
m_Events = events;
// Report
Tools.ExtendedLogging("Found valid Program Guide and using it");
// Done
return;
}
// Report
VCRServer.Log(LoggingLevel.Errors, Properties.Resources.EPGFileCorrupted, ProgramGuideFile.FullName);
// Save delete
try
{
// Process
ProgramGuideFile.Delete();
}
catch
{
// Discard any error
VCRServer.Log(LoggingLevel.Errors, Properties.Resources.EPGDeleteDenied, ProgramGuideFile.FullName);
}
}
static void Main_PSIRun(string[] args)
{
// Create the server
using (VCRServer server = new VCRServer(new DirectoryInfo(@"C:\temp\VCR.NET 3.9 Alpha\Jobs")))
{
// Attach to the profile state of interest
ProfileState nova = server.FindProfile("DVB-S2");
ProfileState nexus = server.FindProfile("Nexus");
// Report
Console.WriteLine("{0} {1}", nova.ProfileName, nova.NextSourceUpdateTime);
Console.WriteLine("{0} {1}", nexus.ProfileName, nexus.NextSourceUpdateTime);
}
}
static void Main6(string[] args)
{
// Attach to job manager
VCRServer server = new VCRServer(new DirectoryInfo(@"C:\temp\VCR.NET 3.9 Alpha\Jobs"));
JobManager jobs = server.JobManager;
// Create EPG collection
using (ZappingRequest request = ZappingRequest.CreateDefault("Nexus Scan", jobs))
if (null != request)
{
// Get the information
FullInfo info0 = request.CreateFullInformation();
// Report
Console.WriteLine(info0.Recording.JobType);
// Start it
request.BeginExecute(false);
// Go to ZDF
LiveModeStatus stat1 = request.SetSource(VCRProfiles.FindSource("Nexus Scan", "ZDF [ZDFvision]"), "localhost:5555");
// Report
Console.WriteLine("ZDF on");
Console.ReadLine();
// Get status
LiveModeStatus stat2 = request.CreateStatus();
// Go to PREMIERE
LiveModeStatus stat3 = request.SetSource(VCRProfiles.FindSource("Nexus Scan", "PREMIERE DIREKT [PREMIERE]"), "localhost:5555");
// Report
Console.WriteLine("PREMIERE on");
Console.ReadLine();
// Get status
LiveModeStatus stat4 = request.CreateStatus();
// Stop it
request.Stop();
// Get the information
FullInfo info1 = request.CreateFullInformation();
}
// Done
Console.WriteLine("Done");
Console.ReadLine();
}
static void Main7(string[] args)
{
// Attach to job manager
VCRServer server = new VCRServer(new DirectoryInfo(@"C:\temp\VCR.NET 3.9 Alpha\Jobs"));
JobManager jobs = server.JobManager;
ProgramGuideEntries entries = new ProgramGuideEntries();
entries.Add(new ProgramGuideEntry {
Name = "Te\x0005st"
});
SerializationTools.Save(entries, @"c:\temp\test.xml");
ProgramGuideEntries reload = SerializationTools.Load <ProgramGuideEntries>(new FileInfo(@"c:\temp\test.xml"));
}
/// <summary>
/// Beendet die Anwendung endgültig.
/// </summary>
public void Dispose()
{
// Forward
var listener = Interlocked.Exchange(ref m_listener, null);
if (listener != null)
{
if (listener.IsListening)
{
try
{
// Process
listener.Stop();
}
catch (Exception)
{
// Report to event log
VCRServer.Log(LoggingLevel.Errors, EventLogEntryType.Warning, Properties.Resources.WebServerStopFailedChannel);
}
}
}
// Wait for all outstanding requests to terminate
while (Thread.VolatileRead(ref m_Threads) > 0)
{
Thread.Sleep(100);
}
// See if worker is up
var runtime = Interlocked.Exchange(ref m_runtime, null);
if (runtime != null)
{
try
{
// Save call - may be already dead
runtime.Stop();
// Terminate the domain
AppDomain.Unload(runtime.AppDomain);
}
catch (Exception)
{
// Report to event log
VCRServer.Log(LoggingLevel.Errors, EventLogEntryType.Warning, Properties.Resources.WebServerStopFailed);
}
}
}
/// <summary>
/// Erstellt eine neue Aktualisierung.
/// </summary>
/// <param name="state">Das zugehörige Geräteprofil.</param>
/// <param name="recording">Daten der primären Aufzeichnung.</param>
private ProgramGuideProxy(ProfileState state, VCRRecordingInfo recording)
: base(state, recording)
{
// Reset fields
if (VCRConfiguration.Current.EnableFreeSat)
{
m_extensions = EPGExtensions.FreeSatUK;
}
else
{
m_extensions = EPGExtensions.None;
}
// All sources we know about
var allSources = new Dictionary <string, SourceSelection>(StringComparer.InvariantCultureIgnoreCase);
// Load all sources of this profile
foreach (var source in VCRProfiles.GetSources(ProfileName))
{
// Remember by direct name
allSources[source.DisplayName] = source;
// allSources by unique name
allSources[source.QualifiedName] = source;
}
// Fill in all
foreach (var legacyName in VCRConfiguration.Current.ProgramGuideSources)
{
// Skip if empty
if (string.IsNullOrEmpty(legacyName))
{
continue;
}
// Locate
SourceSelection realSource;
if (allSources.TryGetValue(legacyName, out realSource))
{
m_selected.Add(realSource.Source);
}
else
{
VCRServer.Log(LoggingLevel.Full, Properties.Resources.BadEPGStation, legacyName);
}
}
}
/// <summary>
/// Beendet den Suchlauf endgültig.
/// </summary>
protected override void OnStop()
{
// Remember the time of the last scan
ProfileState.LastSourceUpdateTime = DateTime.UtcNow;
// Log
VCRServer.Log(LoggingLevel.Full, Properties.Resources.PSIReplace);
// Finish
ServerImplementation.EndRequest(Server.BeginEndScan(m_mergeSources));
// Report
Tools.ExtendedLogging("Card Server has updated Profile {0} - VCR.NET will reload all Profiles now", ProfileName);
// Time to refresh our lists
VCRProfiles.Reset();
}
/// <summary>
/// Beendet die Nutzung dieser Instantz.
/// </summary>
/// <param name="explicitDisposing">Wird ignoriert.</param>
protected override void Dispose(bool explicitDisposing)
{
// Self
try
{
// Forward
AbortWaiter();
}
catch (Exception e)
{
// Report
VCRServer.Log(e);
}
// Forward
base.Dispose(explicitDisposing);
}
/// <summary>
/// Rekonstruiert einen Auftrag und eine Aufzeichnung aus einer Textdarstellung.
/// </summary>
/// <param name="id">Die Textdarstellung.</param>
/// <param name="job">Der ermittelte Auftrag.</param>
/// <returns>Die zugehörige Aufzeichnung im Auftrag.</returns>
public static VCRSchedule ParseUniqueWebId(string id, out VCRJob job)
{
ParseUniqueWebId(id, out Guid jobID, out Guid scheduleID);
// Find the job
job = VCRServer.FindJob(jobID);
// Report schedule if job exists
if (job == null)
{
return(null);
}
else
{
return(job[scheduleID]);
}
}
/// <summary>
/// Beendet einen asynchronen Aufruf. Im Fall einer Ausnahme wird diese nur protokolliert
/// und der Aufruf als abgeschlossen angenommen.
/// </summary>
/// <typeparam name="TAsync">Die Art des Aufrufs.</typeparam>
/// <param name="request">Der aktive Aufruf.</param>
/// <param name="traceFormat">Meldung bei Abschluss des Aufrufs. Ist dieser Parameter <i>null</i>, so
/// wartet die Methode auf den Abschluss des asynchronen Aufrufs.</param>
/// <param name="traceArgs">Parameter zum Aufbau der Meldung.</param>
/// <returns>Gesetzt, wenn der Aufruf abgeschlossen wurde oder bereits war. Ansonsten
/// ist der Aufruf weiterhin aktiv.</returns>
protected bool WaitForEnd <TAsync>(ref TAsync request, string traceFormat = null, params object[] traceArgs) where TAsync : class, IAsyncResult
{
// No request at all
var pending = request;
if (pending == null)
{
return(true);
}
// Request still busy - calling this method with only a single parameter will do a synchronous call
if (traceFormat != null)
{
if (!pending.IsCompleted)
{
return(false);
}
}
// Synchronize
try
{
// Fetch result
ServerImplementation.EndRequest(pending);
// Report
if (!string.IsNullOrEmpty(traceFormat))
{
Tools.ExtendedLogging(traceFormat, traceArgs);
}
}
catch (Exception e)
{
// Report only!
VCRServer.Log(LoggingLevel.Errors, "Failed Operation for '{0}': {1}", ProfileName, e.Message);
}
finally
{
// Forget
request = null;
}
// Stopped it
return(true);
}
static void Main5(string[] args)
{
// Attach to job manager
VCRServer server = new VCRServer(new DirectoryInfo(@"C:\temp\VCR.NET 3.9 Alpha\Jobs"));
JobManager jobs = server.JobManager;
// Create EPG collection
using (SourceScanRequest request = SourceScanRequest.CreateDefault("Nexus Scan", jobs))
if (null != request)
{
// Get the information
FullInfo info0 = request.CreateFullInformation();
// Report
Console.WriteLine(info0.Recording.JobType);
// Start it
request.BeginExecute(false);
// Wait for end
Console.WriteLine("Updateing...");
// Process
for (string line; !string.IsNullOrEmpty(line = Console.ReadLine());)
{
// Get the information
FullInfo info2 = request.CreateFullInformation();
// Report
Console.WriteLine(info2.Recording.TotalSize);
}
// Stop it
request.Stop();
// Get the information
FullInfo info1 = request.CreateFullInformation();
}
// Done
Console.WriteLine("Done");
Console.ReadLine();
}
/// <summary>
/// Beendet die aktuelle ASP.NET Laufzeitumgebung.
/// <seealso cref="ServerRuntime.Stop"/>
/// </summary>
public void Stop()
{
// Terminate all end-points we started
foreach (var endPoint in Interlocked.Exchange(ref m_endPoints, new List <IDisposable>()))
{
try
{
// Try shutdown
endPoint.Dispose();
}
catch (Exception)
{
// Ignore any error
}
}
// Report
VCRServer.Log(LoggingLevel.Full, Properties.Resources.WebServerStopped);
}
/// <summary>
/// Startet eine Aufzeichnung oder eine Aufgabe.
/// </summary>
/// <param name="item">Die Beschreibung der Aufgabe.</param>
/// <returns>Gesetzt, wenn der Vorgang erfolgreich war.</returns>
public bool Start(IScheduleInformation item)
{
// Validate
if (item is ScheduleInformation)
{
VCRServer.LogError(Properties.Resources.BadScheduleInformation, item.Definition.UniqueIdentifier, item.Definition.Name);
}
// Try start
if (!m_manager.Start(item))
{
return(false);
}
// Remember
m_started.Add(item.Definition.UniqueIdentifier, new ScheduleInformation(item));
// Did it
return(true);
}
static void Main(string[] args)
{
// Start server
using (VCRServer server = new VCRServer(new DirectoryInfo(@"C:\temp\VCR.NET 3.9 Alpha\Jobs")))
{
// Load the settings
Settings settings = server.Settings;
// Fire our first schedule
PowerManager.OnResume();
// Report
Console.WriteLine("Running {4} {0} [Hibernate={1} S3={2} NVOD={3}]", string.Join(",", settings.Profiles.ToArray()), settings.MayHibernateSystem, settings.UseStandByForHibernation, settings.CanRecordNVOD, VCRServer.CurrentVersion);
Console.ReadLine();
}
// Done
Console.WriteLine("Done");
Console.ReadLine();
}
static void Main_EPGLookup(string[] args)
{
// Create the server
using (VCRServer server = new VCRServer(new DirectoryInfo(@"C:\temp\VCR.NET 3.9 Alpha\Jobs")))
{
// Create filter
GuideEntryFilter filter =
new GuideEntryFilter
{
MaximumEntriesPerStation = 30,
MinimumDateTime = DateTime.UtcNow,
MinimumIsCurrent = true,
Profile = null,
Station = "ZDF [ZDFvision]",
ContentFilter = null
};
// Load a bit of events
ProgramGuideEntry[] entries = server.GetProgramGuideEntries(filter);
}
}
static void Main_EPGScan(string[] args)
{
// Create the server
using (VCRServer server = new VCRServer(new DirectoryInfo(@"C:\temp\VCR.NET 3.9 Alpha\Jobs")))
{
// Attach to the profile state of interest
ProfileState state = server.FindProfile("DVB-S2");
// Report all
Console.WriteLine(ProgramGuideManager.UpdateEnabled);
Console.WriteLine(state.ProgramGuide.NextUpdateTime);
// Create request
using (ProgramGuideRequest request = state.CreateProgramGuideRequest())
if (null != request)
{
// Manipulate
request.Recording.EndsAt = DateTime.UtcNow.AddSeconds(30);
// Get the information
FullInfo info0 = request.CreateFullInformation();
// Start it
request.Start();
// Wait for end
for (; request.IsRunning; Thread.Sleep(2500))
{
Console.WriteLine("Collecting... {0}", DateTime.Now);
}
// Get the information
FullInfo info1 = request.CreateFullInformation();
// Report
Console.WriteLine(info1.Recording.TotalSize);
}
}
}
static void Main3(string[] args)
{
// Attach to job manager
VCRServer server = new VCRServer(new DirectoryInfo(@"C:\temp\VCR.NET 3.9 Alpha\Jobs"));
JobManager jobs = server.JobManager;
// Get the profile
Profile nexus = VCRProfiles.FindProfile("Nexus");
// Find the next recording
VCRRecordingInfo rec = jobs.FindNextJob(new DateTime(2009, 2, 19, 20, 0, 0), null, nexus);
if (null != rec)
{
if (rec.StartsAt.HasValue)
{
using (RecordingRequest recording = jobs.CreateRecording(rec, rec.StartsAt.Value, nexus))
{
// Get the information
FullInfo info0 = recording.CreateFullInformation();
// Start it
recording.BeginExecute(false);
// Report
Console.WriteLine("Recording...");
Console.ReadLine();
// Get the information
FullInfo info1 = recording.CreateFullInformation();
}
}
}
// Done
Console.WriteLine("Done");
Console.ReadLine();
}
/// <summary>
/// Löst auf einem separaten <see cref="Thread"/> <see cref="OnPowerUp"/> aus.
/// </summary>
public static void OnResume()
{
// Start wakeup thread
new Thread(forbid =>
{
// With reset
using ((IDisposable)forbid)
try
{
// Trigger events
var sink = OnPowerUp;
if (sink != null)
{
sink();
}
}
catch (Exception e)
{
// Report
VCRServer.Log(e);
}
}).Start(StartForbidHibernation());
}
/// <summary>
/// Schließt die Konfiguration einer Beschreibung ab.
/// </summary>
/// <param name="server">Der zugehörige Dienst.</param>
private void Complete(VCRServer server)
{
// No source
if (m_source == null)
{
return;
}
// At least we have this
Source = SourceIdentifier.ToString(m_source.Source).Replace(" ", "");
// Check profile - should normally be available
var profile = server.Profiles[ProfileName];
if (profile == null)
{
return;
}
// Load the profile
HasGuideEntry = profile.ProgramGuide.HasEntry(m_source.Source, StartTime, StartTime + Duration);
SourceName = m_source.GetUniqueName();
}
static void Main_FindRecording(string[] args)
{
// Create the server
using (VCRServer server = new VCRServer(new DirectoryInfo(@"C:\temp\VCR.NET 3.9 Alpha\Jobs")))
{
// Attach to the state of a profile
ProfileState nexus = server.FindProfile("Nexus");
// Get the next job to execute
VCRRecordingInfo next = nexus.NextJob;
// Get recording information for the next jon
bool incomplete;
VCRRecordingInfo[] hidden;
FullInfo full = nexus.FindNextRecording(DateTime.UtcNow, out incomplete, out hidden);
// Prepare it
using (HardwareRequest request = nexus.CreateRecordingRequest(next, DateTime.UtcNow))
{
// Set end time
request.Recording.EndsAt = DateTime.UtcNow.AddSeconds(30);
// Report
Console.WriteLine("Recording {0}", request.Recording.FileName);
// Process it
request.Start();
// Wait
while (request.IsRunning)
{
Thread.Sleep(100);
}
}
}
}
/// <summary>
/// Erstellt eine neue Planung.
/// </summary>
/// <param name="site">Die zugehörige Arbeitsumgebung.</param>
private RecordingPlanner(IRecordingPlannerSite site)
{
// Remember
m_site = site;
// Process all profiles
foreach (var profileName in site.ProfileNames)
{
// Look up the profile
var profile = ProfileManager.FindProfile(profileName);
if (profile == null)
{
continue;
}
// Create the resource for it
var profileResource = ProfileScheduleResource.Create(profileName);
// Remember
m_resources.Add(profileName, profileResource);
// See if this is a leaf profile
if (!string.IsNullOrEmpty(profile.UseSourcesFrom))
{
continue;
}
// See if we should process guide updates
var guideTask = site.CreateProgramGuideTask(profileResource, profile);
if (guideTask != null)
{
m_tasks.Add(guideTask);
}
// See if we should update the source list
var scanTask = site.CreateSourceScanTask(profileResource, profile);
if (scanTask != null)
{
m_tasks.Add(scanTask);
}
}
// Make sure we report all errors
try
{
// Create the manager
m_manager = ResourceManager.Create(site.ScheduleRulesPath, ProfileManager.ProfileNameComparer);
}
catch (Exception e)
{
// Report
VCRServer.LogError(Properties.Resources.BadRuleFile, e.Message);
// Use standard rules
m_manager = ResourceManager.Create(ProfileManager.ProfileNameComparer);
}
// Safe configure it
try
{
// All all resources
foreach (var resource in m_resources.Values)
{
m_manager.Add(resource);
}
}
catch (Exception e)
{
// Cleanup
Dispose();
// Report
VCRServer.Log(e);
}
}
/// <summary>
/// Erstellt eine neue Liste von Beschreibungen für eine aktive Aufzeichnung.
/// </summary>
/// <param name="active">Die Daten zur aktiven Aufzeichnung.</param>
/// <param name="server">Der zugehörige Dienst.</param>
/// <returns>Die gewünschten Beschreibungen.</returns>
public static PlanCurrent[] Create( FullInfo active, VCRServer server )
{
// Validate
if (active == null)
throw new ArgumentNullException( "active" );
// Validate
var recording = active.Recording;
if (recording == null)
throw new ArgumentNullException( "recording" );
// Multiple recordings
var streams = active.Streams;
if (streams != null)
if (streams.Count > 0)
return streams.SelectMany( ( stream, index ) => Create( active, stream, index, server ) ).ToArray();
// Single recording - typically a task
var start = RoundToSecond( active.Recording.PhysicalStart.GetValueOrDefault( DateTime.UtcNow ) );
var end = RoundToSecond( recording.EndsAt );
var source = recording.Source;
var sourceName = source.DisplayName;
// Create
var current =
new PlanCurrent
{
PlanIdentifier = recording.ScheduleUniqueID.Value.ToString( "N" ),
ProfileName = source.ProfileName,
Duration = end - start,
Name = recording.Name,
m_source = source,
StartTime = start,
Files = _NoFiles,
IsLate = false,
Index = -1,
};
// Finish
if (VCRJob.ProgramGuideName.Equals( sourceName ))
current.SizeHint = $"{recording.TotalSize:N0} Einträge";
else if (VCRJob.SourceScanName.Equals( sourceName ))
current.SizeHint = $"{recording.TotalSize:N0} Quellen";
else if (VCRJob.ZappingName.Equals( sourceName ))
current.SizeHint = GetSizeHint( recording.TotalSize );
else
current.Complete( server );
// Report
return new[] { current };
}
/// <summary>
/// Schließt die Konfiguration einer Beschreibung ab.
/// </summary>
/// <param name="server">Der zugehörige Dienst.</param>
private void Complete( VCRServer server )
{
// No source
if (m_source == null)
return;
// At least we have this
Source = SourceIdentifier.ToString( m_source.Source ).Replace( " ", "" );
// Check profile - should normally be available
var profile = server.Profiles[ProfileName];
if (profile == null)
return;
// Load the profile
HasGuideEntry = profile.ProgramGuide.HasEntry( m_source.Source, StartTime, StartTime + Duration );
SourceName = m_source.GetUniqueName();
}
/// <summary>
/// Erstellt eine Beschreibung zu einer einzelnen Aufzeichnung auf einem Gerät.
/// </summary>
/// <param name="active">Beschreibt die gesamte Aufzeichnung.</param>
/// <param name="stream">Die zu verwendende Teilaufzeichnung.</param>
/// <param name="streamIndex">Die laufende Nummer dieses Datenstroms.</param>
/// <param name="server">Der zugehörige Dienst.</param>
/// <returns>Die gewünschte Beschreibung.</returns>
private static IEnumerable<PlanCurrent> Create( FullInfo active, StreamInfo stream, int streamIndex, VCRServer server )
{
// Static data
var recording = active.Recording;
var profileName = recording.Source.ProfileName;
var sizeHint = GetSizeHint( recording.TotalSize ) + " (Gerät)";
// Process all - beginning with VCR.NET 4.1 there is only one schedule per stream
foreach (var scheduleInfo in stream.Schedules)
{
// Try to locate the context
var job = string.IsNullOrEmpty( scheduleInfo.JobUniqueID ) ? null : server.JobManager[new Guid( scheduleInfo.JobUniqueID )];
var schedule = ((job == null) || string.IsNullOrEmpty( scheduleInfo.ScheduleUniqueID )) ? null : job[new Guid( scheduleInfo.ScheduleUniqueID )];
// Create
var start = RoundToSecond( scheduleInfo.StartsAt );
var end = RoundToSecond( scheduleInfo.EndsAt );
var current =
new PlanCurrent
{
Identifier = (schedule == null) ? null : ServerRuntime.GetUniqueWebId( job, schedule ),
PlanIdentifier = scheduleInfo.ScheduleUniqueID,
Files = scheduleInfo.Files ?? _NoFiles,
StreamTarget = stream.StreamsTo,
m_source = scheduleInfo.Source,
ProfileName = profileName,
Name = scheduleInfo.Name,
Duration = end - start,
Index = streamIndex,
SizeHint = sizeHint,
StartTime = start,
};
// Finish
current.Complete( server );
// Report
yield return current;
}
}
/// <summary>
/// Erstellt eine neue Beschreibung aus dem Aufzeichnungsplan.
/// </summary>
/// <param name="plan">Die Planung der Aufzeichnung.</param>
/// <param name="context">Die aktuelle Analyseumgebung.</param>
/// <param name="server">Der zugehörige Dienst.</param>
/// <returns>Die gewünschte Beschreibung.</returns>
public static PlanCurrent Create(IScheduleInformation plan, PlanContext context, VCRServer server)
{
// Attach to the definition
var definition = (IScheduleDefinition <VCRSchedule>)plan.Definition;
var job = context.TryFindJob(definition.UniqueIdentifier);
var schedule = (job == null) ? null : job[definition.UniqueIdentifier];
var source = (schedule == null) ? null : (schedule.Source ?? job.Source);
// Create
var planned =
new PlanCurrent
{
Identifier = (schedule == null) ? null : ServerRuntime.GetUniqueWebId(job, schedule),
ProfileName = plan.Resource.Name,
Duration = plan.Time.Duration,
StartTime = plan.Time.Start,
IsLate = plan.StartsLate,
SizeHint = string.Empty,
Name = definition.Name,
m_source = source,
Files = _NoFiles,
Index = -1,
};
// Finish
planned.Complete(server);
// Report
return(planned);
}
/// <summary>
/// Erstellt eine Beschreibung zu einer einzelnen Aufzeichnung auf einem Gerät.
/// </summary>
/// <param name="active">Beschreibt die gesamte Aufzeichnung.</param>
/// <param name="stream">Die zu verwendende Teilaufzeichnung.</param>
/// <param name="streamIndex">Die laufende Nummer dieses Datenstroms.</param>
/// <param name="server">Der zugehörige Dienst.</param>
/// <returns>Die gewünschte Beschreibung.</returns>
private static IEnumerable <PlanCurrent> Create(FullInfo active, StreamInfo stream, int streamIndex, VCRServer server)
{
// Static data
var recording = active.Recording;
var profileName = recording.Source.ProfileName;
var sizeHint = GetSizeHint(recording.TotalSize) + " (Gerät)";
// Process all - beginning with VCR.NET 4.1 there is only one schedule per stream
foreach (var scheduleInfo in stream.Schedules)
{
// Try to locate the context
var job = string.IsNullOrEmpty(scheduleInfo.JobUniqueID) ? null : server.JobManager[new Guid(scheduleInfo.JobUniqueID)];
var schedule = ((job == null) || string.IsNullOrEmpty(scheduleInfo.ScheduleUniqueID)) ? null : job[new Guid(scheduleInfo.ScheduleUniqueID)];
// Create
var start = RoundToSecond(scheduleInfo.StartsAt);
var end = RoundToSecond(scheduleInfo.EndsAt);
var current =
new PlanCurrent
{
Identifier = (schedule == null) ? null : ServerRuntime.GetUniqueWebId(job, schedule),
PlanIdentifier = scheduleInfo.ScheduleUniqueID,
Files = scheduleInfo.Files ?? _NoFiles,
StreamTarget = stream.StreamsTo,
m_source = scheduleInfo.Source,
ProfileName = profileName,
Name = scheduleInfo.Name,
Duration = end - start,
Index = streamIndex,
SizeHint = sizeHint,
StartTime = start,
};
// Finish
current.Complete(server);
// Report
yield return(current);
}
}
/// <summary>
/// Erstellt eine neue Beschreibung aus dem Aufzeichnungsplan.
/// </summary>
/// <param name="plan">Die Planung der Aufzeichnung.</param>
/// <param name="context">Die aktuelle Analyseumgebung.</param>
/// <param name="server">Der zugehörige Dienst.</param>
/// <returns>Die gewünschte Beschreibung.</returns>
public static PlanCurrent Create( IScheduleInformation plan, PlanContext context, VCRServer server )
{
// Attach to the definition
var definition = (IScheduleDefinition<VCRSchedule>) plan.Definition;
var job = context.TryFindJob( definition.UniqueIdentifier );
var schedule = (job == null) ? null : job[definition.UniqueIdentifier];
var source = (schedule == null) ? null : (schedule.Source ?? job.Source);
// Create
var planned =
new PlanCurrent
{
Identifier = (schedule == null) ? null : ServerRuntime.GetUniqueWebId( job, schedule ),
ProfileName = plan.Resource.Name,
Duration = plan.Time.Duration,
StartTime = plan.Time.Start,
IsLate = plan.StartsLate,
SizeHint = string.Empty,
Name = definition.Name,
m_source = source,
Files = _NoFiles,
Index = -1,
};
// Finish
planned.Complete( server );
// Report
return planned;
}
/// <summary>
/// Verbindet die ASP.NET Laufzeitumgebung des aktuellen virtuellen Verzeichnisses
/// mit der aktiven VCR.NET Instanz.
/// </summary>
/// <param name="server">Die aktive VCR.NET Instanz.</param>
public void SetServer( VCRServer server )
{
// Activate configuration from main domain
VCRConfiguration.Register( server.Configuration );
// Add to permanent cache
_VCRServer = server;
}
/// <summary>
/// Beendet die ASP.NET Laufzeitumgebung.
/// </summary>
/// <remarks>
/// Der Aufruf kehrt erst wieder zurück, wenn alle ausstehenden Anfragen bearbeitet
/// wurden. Neue Anfragen werden nicht angenommen.
/// </remarks>
public override void Stop()
{
// Reset
_VCRServer = null;
// Forward
base.Stop();
}
