protected override void OnStop()
{
timer.Stop();
timer.Dispose();
PublishingLog.WriteEntry("Comment Publishing Service Stopped.", EventLogEntryType.Information);
MailControler.MailToWebmaster("Comment Service Stopped", "Comment Publishing Service has stopped.");
}
protected virtual void AddLog(IncomeQueue queueItem, QueueStatus logStatus, Exception e = null)
{
PublishingLog log = new PublishingLog()
{
UUID = Kooboo.UniqueIdGenerator.GetInstance().GetBase32UniqueId(20),
QueueType = QueueType.Incoming,
QueueUUID = queueItem.UUID,
ObjectTitle = queueItem.ObjectTitle,
SiteName = queueItem.SiteName,
PublishingObject = queueItem.PublishingObject,
ObjectUUID = queueItem.ObjectUUID,
//PublishingType = PublishingType.Remote,
RemoteEndpoint = null,
TextFolderMapping = null,
UserId = queueItem.Vendor,
Status = logStatus,
Vendor = queueItem.Vendor,
UtcProcessedTime = queueItem.UtcProcessedTime,
Message = e == null ? queueItem.Message : e.Message,
StackTrace = e == null ? "" : e.StackTrace,
PublishingAction = queueItem.Action,
QueueObject = queueItem
};
_publishingLogProvider.Add(log);
}
/// <summary>
/// Determine if current item should be excluded from publishing or not.
/// If it should be excluded, the current pipeline is aborted.
/// Override this method for any custom implementation logic.
/// </summary>
/// <param name="context">context of the item being published</param>
protected virtual void ProcessPublishItem(PublishItemContext context)
{
try
{
Assert.ArgumentNotNull((object)context, "context");
Assert.ArgumentNotNull((object)context.PublishOptions, "context.PublishOptions");
if (context.VersionToPublish == null)
{
// Case 1: handled case where deleted items also should get excluded from publishing
// Case 2: handled case where shared fields of an item should be excluded from publishing
if (context.Action == PublishAction.DeleteTargetItem && context.PublishOptions != null)
{
Item deletedItem = context.PublishOptions.TargetDatabase.GetItem(context.ItemId);
if (deletedItem == null)
{
return;
}
context.VersionToPublish = deletedItem;
}
else if (context.Action == PublishAction.PublishSharedFields && context.PublishOptions != null)
{
Item sharedItem = context.PublishOptions.SourceDatabase.GetItem(context.ItemId);
if (sharedItem == null)
{
return;
}
context.VersionToPublish = sharedItem;
}
else
{
return;
}
}
PublishingLog.Debug(string.Format("Sitecore.PublishExclusions : SkipExcludedItems processing item - '{0}'", context.VersionToPublish.Paths.Path));
// Check if item comes under any one of exluded nodes and also not under included nodes then abort pipeline.
if (PublishExclusionsContext.Current.IsExcludedForCurrentPublish(context))
{
PublishingLog.Debug(string.Format("Sitecore.PublishExclusions : SkipExcludedItems skipping item - '{0}'", context.VersionToPublish.Paths.Path));
string explanation = string.Format(ExplanationTextFormat, context.VersionToPublish.Paths.Path);
context.Result = new PublishItemResult(PublishOperation.Skipped, PublishChildAction.Skip, explanation, PublishExclusionsContext.Current.ReturnItemsToPublishQueue);
context.AbortPipeline();
}
//if publish action item is shared fields and version to publish has been manually set to an item then set it back to null
if (context.Action == PublishAction.PublishSharedFields && context.VersionToPublish != null)
{
context.VersionToPublish = null;
}
}
catch (Exception ex)
{
PublishingLog.Error("Sitecore.PublishExclusions : SkipExcludedItems publish item processor - error in skipping excluded items", ex);
}
}
private void AddLog(OutgoingQueue queueItem, Exception e)
{
PublishingLog log = new PublishingLog()
{
UUID = Kooboo.UniqueIdGenerator.GetInstance().GetBase32UniqueId(20),
QueueType = QueueType.Outgoing,
QueueUUID = queueItem.UUID,
SiteName = queueItem.SiteName,
PublishingObject = queueItem.PublishingObject,
ObjectUUID = queueItem.ObjectUUID,
//PublishingType = PublishingType.Remote,
RemoteEndpoint = null,
TextFolderMapping = null,
UserId = null,
Status = queueItem.Status,
Vendor = null,
UtcProcessedTime = queueItem.UtcLastExecutedTime,
Message = e == null ? queueItem.Message : e.Message,
StackTrace = e == null ? "" : e.StackTrace,
PublishingAction = queueItem.Action,
QueueObject = queueItem
};
_publishingLogProvider.Add(log);
}
public virtual void Delete(string[] uuids)
{
foreach (string uuid in uuids)
{
var model = new PublishingLog(uuid).AsActual();
this._outgoingLogProvider.Remove(model);
}
}
public virtual void Delete(Site site, string[] uuids)
{
foreach (string uuid in uuids)
{
var model = new PublishingLog(site, uuid).AsActual();
if (model != null)
{
this._outgoingLogProvider.Remove(model);
}
}
}
public override SitecoreDeployCommandArguments Execute(SitecoreDeployCommandArguments args)
{
Assert.ArgumentNotNull(args, nameof(args));
args.Result = "";
var master = Database.GetDatabase("master");
var web = Database.GetDatabase("web");
var targets = new[] { web };
var mode = (args["arg"] ?? "smart").ToLowerInvariant();
var languages = LanguageManager.GetLanguages(master).ToArray();
switch (mode)
{
case "smart":
{
PublishingLog.Info("DeployService.PublishService Started Smart Publish");
PublishManager.PublishSmart(master, targets, languages);
JobsCount.TasksPublishings.Increment();
args.Result = "SitecoreDeploy: Started Smart Publish";
break;
}
case "full":
{
PublishingLog.Info("DeployService.PublishService Started Full Publish");
foreach (var l in languages)
{
PublishManager.Publish(new[]
{ new PublishOptions(master, web, PublishMode.Full, l, DateTime.Now) });
JobsCount.TasksPublishings.Increment();
args.Result += $"SitecoreDeploy: Started Full Publish for '{l}'\r\n";
}
break;
}
case "incremental":
{
PublishingLog.Info("DeployService.PublishService Started Incremental Publish");
PublishManager.PublishIncremental(master, targets, languages);
JobsCount.TasksPublishings.Increment();
args.Result = "SitecoreDeploy: Started Incremental Publish";
break;
}
default: throw new ArgumentException($"unknown mode '{mode}'");
}
return(args);
}
void prepQueueTimer_Elapsed(object sender, ElapsedEventArgs e)
{
foreach (String file in Directory.GetFiles(PublishDirectory))
{
if (file.EndsWith(".pubreq") && !WorkingQueue.Contains(file) && !PendingQueue.Contains(file))
{
PublishingLog.WriteEntry("Queueing Reqeust " + file, EventLogEntryType.Information);
PendingQueue.Add(file);
}
}
if (!Working)
{
timer_Elapsed(prepQueueTimer, null);
}
}
void timer_Elapsed(object sender, ElapsedEventArgs e)
{
if (Working)
{
PublishingLog.WriteEntry("Process is taking a while... Queue is working.", EventLogEntryType.Warning);
return;
}
if (PendingQueue.Count > 0)
{
WorkingQueue.AddRange(PendingQueue);
PendingQueue.Clear();
}
else
{
return;
}
Working = true;
if (WorkingQueue.Count > 0)
{
PublishingLog.WriteEntry(String.Format("{0} files are queued for this round.", WorkingQueue.Count), EventLogEntryType.Information);
}
foreach (String fileName in WorkingQueue)
{
PublishingLog.WriteEntry("Beginning to publish " + fileName);
try
{
PublishRequest.ExecuteRequest(fileName);
PublishingLog.WriteEntry(String.Format("Completed Publish Request: {0}", fileName));
}
catch (Exception xmlex)
{
PublishingLog.WriteEntry(xmlex.Message, EventLogEntryType.Error);
}
}
Working = false;
WorkingQueue.Clear();
}
private void SendLog(PublishingLog item)
{
if (item.Site != null)
{
var site = item.Site.AsActual();
//have set smtp
if (site != null && site.Smtp != null && !string.IsNullOrEmpty(site.Smtp.Host) && !string.IsNullOrEmpty(site.Smtp.From)
&& site.Smtp.To != null && site.Smtp.To.Length > 0)
{
var logMessage = @"
Log type : {0},
Action : {1},
Item type : {2},
Title : {3},
Object UUID : {4}
Remote sites: {5},
Folder mapping:{6},
User : {7},
Status : {8}
Processed time:{9},
Message : {10},
Stack trace : {11}
";
logMessage = string.Format(logMessage, item.QueueType,
item.PublishingAction,
item.PublishingObject,
item.ObjectTitle,
item.ObjectUUID,
string.IsNullOrEmpty(item.RemoteEndpoint) ? "-" : item.RemoteEndpoint,
string.IsNullOrEmpty(item.TextFolderMapping) ? "-" : item.TextFolderMapping,
string.IsNullOrEmpty(item.UserId) ? "-" : item.UserId,
item.Status,
item.UtcProcessedTime.Value.ToLocalTime(),
string.IsNullOrEmpty(item.Message) ? "-" : item.Message,
string.IsNullOrEmpty(item.StackTrace) ? "-" : item.StackTrace);
site.SendMailToSiteManager(site.Smtp.From, "Publishing log", logMessage, false);
}
}
}
protected virtual void AddLog(RemotePublishingQueue queueItem, QueueStatus logStatus, PublishingAction action, Exception e = null)
{
PublishingLog log = new PublishingLog(queueItem.Site, Kooboo.UniqueIdGenerator.GetInstance().GetBase32UniqueId(20))
{
QueueType = QueueType.Remote,
QueueUUID = queueItem.UUID,
ObjectTitle = queueItem.ObjectTitle,
PublishingObject = queueItem.PublishingObject,
ObjectUUID = queueItem.ObjectUUID,
RemoteEndpoint = null,
TextFolderMapping = null,
UserId = queueItem.UserId,
Status = logStatus,
Vendor = null,
UtcProcessedTime = DateTime.UtcNow,
Message = e == null ? queueItem.Message : e.Message,
StackTrace = e == null ? "" : e.StackTrace,
PublishingAction = action,
QueueObject = queueItem
};
_publishingLogProvider.Add(log);
}
protected override void OnStart(string[] args)
{
timer.Start();
PublishingLog.WriteEntry("Comment Publishing Service Started.", EventLogEntryType.Information);
MailControler.MailToWebmaster("Comment Service Started", "Comment Publishing Service has been started.");
}
