public void Build(string[] arguments)
{
try
{
//check if another instance is running - if so exit
ExecutionLogLogger.SetExecutionStartTime(DateTime.Now);
var isProcessRunning = Process.GetProcessesByName(Path.GetFileNameWithoutExtension(Assembly.GetEntryAssembly().Location)).Length > 1;
if (isProcessRunning)
{
Log.Info("Another instance was running, so exiting the application without any processing.");
return;
}
Log.Info("Execution started!");
if (OutputInstructionProcessor.Initialize())
{
Log.Info("Instruction processor processed instructions from the previous exection. Exiting the application without executing a new run.");
return;
}
var feed = FeedService.GetFeed(FeedId);
if (feed.IsPaused)
{
Log.InfoFormat("{0} feed is paused. Exiting application without any processing.", feed.Name);
return;
}
// First decide if a full run should be enforced.
var lastSuccessfulRun = FeedRunService.GetLastSuccessfulRun(FeedId);
var enforceFullRun = ShouldEnforceFullRun(arguments, lastSuccessfulRun);
var isPseudoFullRun = false;
// If a full run is being enforced, but there is an existing successful run, execute an incremental run, where we still send products
// that haven't been modified/touched by rule changes. This is necessary because a product expires in 30 days in Google if no updates
// about the product is sent. The solution we came up with regarding this behavior is having 2 schedules for this feed generator, where one will run
// only once a week and enforce a "full run". If we're in such a pseudo full run, then we'll execute an incremental run, while ensuring that unmodified
// product data still gets passed.
if (enforceFullRun && lastSuccessfulRun != null)
{
isPseudoFullRun = true;
}
// Next, need to decide on the effective start time.
_currentRun = FeedRunService.GetOrCreateActiveFeedRun(FeedId, enforceFullRun && !isPseudoFullRun, AllowIncrementalRuns);
DateTime?fromTime = null;
DateTime?effectiveStartTime = null;
// Only set these values if we aren't in a "real" full run
if (!(enforceFullRun && !isPseudoFullRun))
{
fromTime = GetFromTime(_currentRun);
// Effective start time is used for callibrating the fromTime to a previous point in time, in case this is needed due to the execution
// sequence/timinig of other processes that impact the data that the inventory feed depends on. For example, if results of an inventory-related
// process takes 2 hours to get replicated down to the catalogue/website, where as the inventory data has already been updated in Bronte at
// the time of execution AND business has updated rules related to the feed in the past 15 minutes, then gathering the incremental data as
// if the run started two hours ago but applying rule changes using "now" as the reference point will yield more "accurate" results.
effectiveStartTime = fromTime;
if (_currentRun.FeedRunType == FeedRunType.Incremental)
{
effectiveStartTime = fromTime.Value.AddHours(-IncrementalRunBufferTimeLength);
}
}
_effectiveExecutionEndTime = DateTime.Now;
Runner.Initialize(ExecutionLogLogger, GooglePlaFeedId, _currentRun.FeedRunType == FeedRunType.Incremental, fromTime, effectiveStartTime, _effectiveExecutionEndTime, isPseudoFullRun);
ExecutionLogLogger = Runner.Execute();
// Ensure that we kill the watcher here as well
if (ExecutionLogLogger.HasError)
{
Log.Error("Execution failed!!! Exiting application without further processing.");
HandleExit();
return;
}
HandleSuccess();
var elapsedTime = DateTime.Now - ExecutionLogLogger.GetExecutionStartTime();
Log.InfoFormat("Execution completed in {0}", elapsedTime.ToString(@"dd\.hh\:mm\:ss"));
}
catch (Exception e)
{
Log.Error("Execution failed!!!", e);
HandleExit();
}
}
public void Build(string[] args)
{
try
{
//check if another instance is running - if so exit
ExecutionLogLogger.SetExecutionStartTime(DateTime.Now);
ExecutionLogLoggerSecondary.SetExecutionStartTime(DateTime.Now);
var isProcessRunning = Process.GetProcessesByName(Path.GetFileNameWithoutExtension(Assembly.GetEntryAssembly().Location)).Length > 1;
if (isProcessRunning)
{
Log.Info("Another instance was running, so exiting the application without any processing.");
return;
}
// First check if the "done" file is there. If so, skip job execution and move to file-related steps
if (HasDoneFile())
{
Log.Info("Done file exists at the drop folder. Skipping job execution and moving to file operations.");
ExecuteFileOperations();
return;
}
Log.Info("Execution started!");
var feed = FeedService.GetFeed(FeedId);
IFeed secondaryFeed = null;
if (RunMode == RunMode.PrimaryAndSecondary)
{
secondaryFeed = FeedService.GetFeed(FeedIdSecondary);
}
var allowPrimary = !feed.IsPaused;
var allowSecondary = secondaryFeed != null && !secondaryFeed.IsPaused;
if (!allowPrimary && !allowSecondary)
{
Log.InfoFormat("Both primary {0} and secondary {1} feeds are paused. Exiting application without any processing.", feed.Name, secondaryFeed.Name);
return;
}
// If one of the feeds is paused, notify the user and move on
if (!allowPrimary)
{
Log.InfoFormat("The primary feed {0} is in paused state. Skipping primary feed.", feed.Name);
}
if (RunMode == RunMode.PrimaryAndSecondary && !allowSecondary)
{
Log.InfoFormat("The secondary feed {0} is in paused state. Skipping secondary feed.", secondaryFeed.Name);
}
// First clean all the files inside the output folder (in case the previous run failed and left out old files behind.)
RemoveOldFiles();
_currentRun = FeedRunService.GetOrCreateActiveFeedRun(feed.FeedId, true, false);
int?secondaryRunId = null;
if (RunMode == RunMode.PrimaryAndSecondary)
{
_currentSecondaryRun = FeedRunService.GetOrCreateActiveFeedRun(secondaryFeed.FeedId, true, false);
secondaryRunId = _currentSecondaryRun.FeedId;
}
_effectiveExecutionEndTime = DateTime.Now;
Runner.Initialize(ExecutionLogLogger, ExecutionLogLoggerSecondary, _currentRun.FeedId, secondaryRunId);
var results = Runner.Execute().ToList();
ExecutionLogLogger = results[0];
if (RunMode == RunMode.PrimaryAndSecondary)
{
ExecutionLogLoggerSecondary = results[1];
}
if (ExecutionLogLogger.HasError || ExecutionLogLoggerSecondary.HasError)
{
Log.Error("Execution failed!!! Exiting application without moving any files.");
HandleExit();
return;
}
HandleSuccess();
var elapsedTime = DateTime.Now - ExecutionLogLogger.GetExecutionStartTime();
Log.InfoFormat("Execution completed in {0}", elapsedTime.ToString(@"dd\.hh\:mm\:ss"));
}
catch (Exception e)
{
Log.Error("Execution failed!!!", e);
HandleExit();
}
}