public void Publish(TransportMessage message, PublishOptions publishOptions)
{
if (SubscriptionStorage == null)
{
throw new InvalidOperationException("Cannot publish on this endpoint - no subscription storage has been configured.");
}
var eventTypesToPublish = MessageMetadataRegistry.GetMessageMetadata(publishOptions.EventType.FullName)
.MessageHierarchy
.Distinct()
.ToList();
var subscribers = SubscriptionStorage.GetSubscriberAddressesForMessage(eventTypesToPublish.Select(t => new MessageType(t))).ToList();
if (!subscribers.Any())
{
PipelineExecutor.CurrentContext.Set("NoSubscribersFoundForMessage",true);
return;
}
PipelineExecutor.CurrentContext.Set("SubscribersForEvent", subscribers);
foreach (var subscriber in subscribers)
{
//this is unicast so we give the message a unique ID
message.ChangeMessageId(CombGuid.Generate().ToString());
MessageSender.Send(message, new SendOptions(subscriber)
{
ReplyToAddress = publishOptions.ReplyToAddress,
EnforceMessagingBestPractices = publishOptions.EnforceMessagingBestPractices,
EnlistInReceiveTransaction = publishOptions.EnlistInReceiveTransaction,
});
}
}
void Publish(IPublishBrokeredMessages publisher, TransportMessage message, PublishOptions options)
{
using (var brokeredMessage = message.ToBrokeredMessage(options, config.Settings, config))
{
publisher.Publish(brokeredMessage);
}
}
public void IgnoredBestPractices_Should_Return_True_When_Disabled_Best_Practice_Enforcement()
{
var options = new PublishOptions();
options.DoNotEnforceBestPractices();
Assert.IsTrue(options.IgnoredBestPractices());
}
public void GetMessageId_Should_Return_Defined_Id()
{
const string expectedMessageID = "expected message id";
var options = new PublishOptions();
options.SetMessageId(expectedMessageID);
Assert.AreEqual(expectedMessageID, options.GetMessageId());
}
public void GetHeaders_Should_Return_Collection_With_MessageId_Header_Configured()
{
var options = new PublishOptions();
var result = options.GetHeaders();
Assert.AreEqual(1, result.Count);
CollectionAssert.Contains(result.Keys, Headers.MessageId);
}
public OutgoingPublishContext(OutgoingLogicalMessage message, PublishOptions options, IBehaviorContext parentContext)
: base(options.MessageId, new Dictionary<string, string>(options.OutgoingHeaders), parentContext)
{
Message = message;
Guard.AgainstNull(nameof(parentContext), parentContext);
Guard.AgainstNull(nameof(message), message);
Guard.AgainstNull(nameof(options), options);
parentContext.Extensions.Merge(options.Context);
}
void PublishMessage(TransportMessage message, PublishOptions publishOptions, dynamic channel)
{
var eventType = publishOptions.EventType;
var properties = channel.CreateBasicProperties();
KafkaTransportMessageExtensions.FillKafkaProperties(message, publishOptions, properties);
RoutingTopology.Publish(channel, eventType, message, properties);
}
public void Publish(TransportMessage message, PublishOptions options)
{
var publisher = topology.GetPublisher(config.LocalAddress);
if (publisher == null) throw new QueueNotFoundException { Queue = config.LocalAddress };
if (!config.Settings.Get<bool>("Transactions.Enabled") || Transaction.Current == null)
Publish(publisher, message, options);
else
Transaction.Current.EnlistVolatile(new SendResourceManager(() => Publish(publisher, message, options)), EnlistmentOptions.None);
}
public async Task Publish_ShouldContainMessageInPublishedMessages()
{
var context = new TestableMessageHandlerContext();
var messageInstance = new TestMessage();
var publishOptions = new PublishOptions();
await context.Publish(messageInstance, publishOptions);
Assert.AreEqual(1, context.PublishedMessages.Length);
Assert.AreSame(messageInstance, context.PublishedMessages[0].Message);
Assert.AreSame(publishOptions, context.PublishedMessages[0].Options);
}
static async Task AsyncMain()
{
Console.Title = "Samples.MultiTenant.Sender";
const string letters = "ABCDEFGHIJKLMNOPQRSTUVXYZ";
var random = new Random();
var endpointConfiguration = new EndpointConfiguration("Samples.MultiTenant.Sender");
endpointConfiguration.UseSerialization<JsonSerializer>();
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.UsePersistence<NHibernatePersistence>();
endpointConfiguration.EnableOutbox();
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
try
{
Console.WriteLine("Press A or B to publish a message (A and B are tenant IDs)");
var acceptableInput = new List<char> { 'A', 'B' };
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
var uppercaseKey = char.ToUpperInvariant(key.KeyChar);
if (acceptableInput.Contains(uppercaseKey))
{
var orderId = new string(Enumerable.Range(0, 4).Select(x => letters[random.Next(letters.Length)]).ToArray());
var message = new OrderSubmitted
{
OrderId = orderId,
Value = random.Next(100)
};
var options = new PublishOptions();
options.SetHeader("TenantId", uppercaseKey.ToString());
await endpointInstance.Publish(message, options)
.ConfigureAwait(false);
}
else
{
Console.WriteLine($"[{uppercaseKey}] is not a valid tenant identifier.");
}
}
}
finally
{
await endpointInstance.Stop()
.ConfigureAwait(false);
}
}
public async Task PublishAsync(TransportMessage message, PublishOptions options)
{
ServiceBusMessageSender sender;
if (!this.publisherCache.TryGetValue(options.Topic, out sender))
{
sender = await this.factory.CreateMessageSenderAsync(options.Destination())
.ConfigureAwait(false);
this.publisherCache.TryAdd(options.Topic, sender);
}
await sender.SendAsync(message.ToBrokeredMessage())
.ConfigureAwait(false);
}
public void Publish()
{
//We need the target database
Database webDb = Sitecore.Configuration.Factory.GetDatabase("web");
//We need to know the language to publish. Here we use the context language
Language language = Sitecore.Context.Language;
//We set the publish date to now
DateTime publishTime = DateTime.Now;
//Now we can create the publish options
Sitecore.Publishing.PublishOptions options = new PublishOptions(masterDb, webDb, PublishMode.SingleItem, language, publishTime);
//Activate the publishpipeline
Sitecore.Publishing.Pipelines.PublishItem.PublishItemPipeline.Run(item.ID, options);
}
public static BrokeredMessage ToBrokeredMessage(this TransportMessage message, PublishOptions options, ReadOnlySettings settings, Configure config)
{
var brokeredMessage = BrokeredMessageBodyConversion.InjectBody(message.Body);
SetHeaders(message, options, settings, config, brokeredMessage);
if (message.TimeToBeReceived < TimeSpan.MaxValue)
{
brokeredMessage.TimeToLive = message.TimeToBeReceived;
}
GuardMessageSize(brokeredMessage);
return brokeredMessage;
}
public void ShouldShallowCloneHeaders()
{
var message = new OutgoingLogicalMessage(typeof(object), new object());
var options = new PublishOptions();
options.SetHeader("someHeader", "someValue");
var testee = new OutgoingPublishContext(message, options, new RootContext(null, null, null));
testee.Headers["someHeader"] = "updatedValue";
testee.Headers["anotherHeader"] = "anotherValue";
Assert.AreEqual("someValue", options.OutgoingHeaders["someHeader"]);
Assert.IsFalse(options.OutgoingHeaders.ContainsKey("anotherHeader"));
Assert.AreEqual("updatedValue", testee.Headers["someHeader"]);
Assert.AreEqual("anotherValue", testee.Headers["anotherHeader"]);
}
public async Task Handle(MyMessage message, IMessageHandlerContext context)
{
SendOptions sendOptions = new SendOptions();
sendOptions.SetHeader("MyCustomHeader", "My custom value");
await context.Send(new SomeOtherMessage(), sendOptions);
ReplyOptions replyOptions = new ReplyOptions();
replyOptions.SetHeader("MyCustomHeader", "My custom value");
await context.Reply(new SomeOtherMessage(), replyOptions);
PublishOptions publishOptions = new PublishOptions();
publishOptions.SetHeader("MyCustomHeader", "My custom value");
await context.Publish(new SomeOtherMessage(), publishOptions);
}
public void When_publishing_should_clone_headers()
{
var publishPipeline = new FakePipeline <IOutgoingPublishContext>();
var messageOperations = CreateMessageOperations(publishPipeline: publishPipeline);
var publishOptions = new PublishOptions();
publishOptions.SetHeader("header1", "header1 value");
messageOperations.Publish <MyMessage>(new FakeRootContext(), m => { }, publishOptions);
publishPipeline.ReceivedContext.Headers.Add("header2", "header2 value");
publishPipeline.ReceivedContext.Headers["header1"] = "updated header1 value";
var optionsHeaders = publishOptions.GetHeaders();
Assert.AreEqual(1, optionsHeaders.Count);
Assert.AreEqual("header1 value", optionsHeaders["header1"]);
}
Task Publish(IBehaviorContext context, Type messageType, object message, PublishOptions options)
{
var messageId = options.UserDefinedMessageId ?? CombGuid.Generate().ToString();
var headers = new Dictionary <string, string>(options.OutgoingHeaders)
{
[Headers.MessageId] = messageId
};
var publishContext = new OutgoingPublishContext(
new OutgoingLogicalMessage(messageType, message),
messageId,
headers,
options.Context,
context);
return(publishPipeline.Invoke(publishContext));
}
public void ShouldShallowCloneHeaders()
{
var message = new OutgoingLogicalMessage(typeof(object), new object());
var options = new PublishOptions();
options.SetHeader("someHeader", "someValue");
var testee = new OutgoingPublishContext(message, options, new RootContext(null, null, null));
testee.Headers["someHeader"] = "updatedValue";
testee.Headers["anotherHeader"] = "anotherValue";
Assert.AreEqual("someValue", options.OutgoingHeaders["someHeader"]);
Assert.IsFalse(options.OutgoingHeaders.ContainsKey("anotherHeader"));
Assert.AreEqual("updatedValue", testee.Headers["someHeader"]);
Assert.AreEqual("anotherValue", testee.Headers["anotherHeader"]);
}
public static bool PublishQueuedItems(Item triggerItem, Database[] targets, IProgressStatus progress = null)
{
if (ManuallyAddedCandidates.Count == 0) return false;
foreach (var database in targets)
{
if (progress != null) progress.ReportStatus("> Publishing {0} synced item{2} in queue to {1}", MessageType.Debug, ManuallyAddedCandidates.Count, database.Name, ManuallyAddedCandidates.Count == 1 ? string.Empty : "s");
var publishOptions = new PublishOptions(triggerItem.Database, database, PublishMode.SingleItem, triggerItem.Language, DateTime.UtcNow) { RootItem = triggerItem };
var result = new Publisher(publishOptions).PublishWithResult();
if (progress != null) progress.ReportStatus("> Published synced items to {0} (New: {1}, Updated: {2}, Deleted: {3} Skipped: {4})", MessageType.Debug, database.Name, result.Statistics.Created, result.Statistics.Updated, result.Statistics.Deleted, result.Statistics.Skipped);
}
return true;
}
private void CopyPlan(Item item)
{
var eventItem = new Entities.EventItem(item);
var planRoot = (Sitecore.Context.ContentDatabase ?? Sitecore.Context.Database).GetItem("{963678A4-869C-48AB-915B-D18C6D2AF357}");
//TODO: Create more unike path
var copiedPlanItem = eventItem.EventRoot.EngangementPlanItem.CopyTo(planRoot, item.Name);
eventItem.PlanId = copiedPlanItem.ID.Guid;
//Set the workflow state on the plan to deploy.
// TODO: Move this to a deploy button instead!
IWorkflow workflow = copiedPlanItem.State.GetWorkflow();
Item workflowCommandItem = ItemUtil.GetContentItem(Guid.Parse("{4044A9C4-B583-4B57-B5FF-2791CB0351DF}"));
if (workflow == null)
{
copiedPlanItem.Database.DataManager.SetWorkflowInfo(copiedPlanItem,
new WorkflowInfo(workflowCommandItem.Parent.Parent.ID.ToString(), workflowCommandItem.Parent.ID.ToString()));
workflow = copiedPlanItem.State.GetWorkflow();
}
WorkflowInfo workflowInfo = copiedPlanItem.Database.DataManager.GetWorkflowInfo(copiedPlanItem);
if (workflowInfo == null || workflowInfo.StateID != workflowCommandItem.Parent.ID.ToString())
{
return;
}
WorkflowResult workflowResult = workflow.Execute("{4044A9C4-B583-4B57-B5FF-2791CB0351DF}", copiedPlanItem,
"Executed from Events save event", false, new object());
PublishOptions options = new PublishOptions(copiedPlanItem.Database, Database.GetDatabase("web"), PublishMode.Smart, copiedPlanItem.Language, DateTime.Now)
{
Deep = true,
RootItem = copiedPlanItem
};
Publisher p = new Publisher(options);
p.PublishAsync();
}
public async Task Should_use_transaction_in_transport_operations()
{
var context = await Scenario.Define <MyContext>()
.WithEndpoint <AnEndpoint>(c => c.When(async bus =>
{
using (var connection = new SqlConnection(ConnectionString))
{
connection.Open();
SendOptions sendOptions;
PublishOptions publishOptions;
using (var rolledbackTransaction = connection.BeginTransaction())
{
sendOptions = new SendOptions();
sendOptions.UseCustomSqlTransaction(rolledbackTransaction);
await bus.Send(new CommandFromRolledbackTransaction(), sendOptions);
publishOptions = new PublishOptions();
publishOptions.UseCustomSqlTransaction(rolledbackTransaction);
await bus.Publish(new EventFromRollbackedTransaction(), publishOptions);
rolledbackTransaction.Rollback();
}
using (var committedTransaction = connection.BeginTransaction())
{
sendOptions = new SendOptions();
sendOptions.UseCustomSqlTransaction(committedTransaction);
await bus.Send(new CommandFromCommittedTransaction(), sendOptions);
publishOptions = new PublishOptions();
publishOptions.UseCustomSqlTransaction(committedTransaction);
await bus.Publish(new EventFromCommittedTransaction(), publishOptions);
committedTransaction.Commit();
}
}
}))
.Done(c => c.SendFromCommittedTransactionReceived && c.PublishFromCommittedTransactionReceived)
.Run(TimeSpan.FromMinutes(1));
Assert.IsFalse(context.SendFromRolledbackTransactionReceived);
Assert.IsFalse(context.PublishFromRolledbackTransactionReceived);
}
public async Task PublishAsync <T>(IEnumerable <T> messages, PublishOptions publishOptions = default,
CancellationToken cancellationToken = default) where T : IMessage
{
await Semaphore.WaitAsync(cancellationToken);
try
{
var options = SetupExchange(publishOptions);
messages.ToList().ForEach(message =>
{
Send(message, options);
});
}
finally
{
Semaphore.Release();
}
}
public async Task Build(PublishOptions options)
{
await Task.Run(() =>
{
var project =
ProjectCollection.GlobalProjectCollection.LoadedProjects.FirstOrDefault(
x => x.FullPath.ToLower() == options.ProjectFilePath.ToLower()) ??
new Project(options.ProjectFilePath);
project.SetProperty("Configuration", "Release");
var success = project.Build(new FileLogger());
if (!success)
{
throw new Exception("build failed. see msbuild.log for more details");
}
});
}
public override void Process(ImportEntityPipelineArgs args, BaseLog logger)
{
var source = args.Item.Database;
var target = Factory.GetDatabase("web");
PublishOptions publishOptions = new PublishOptions(source, target, PublishMode.SingleItem, args.Item.Language, DateTime.Now)
{
RootItem = args.Item,
Deep = true,
PublishRelatedItems = true
};
var publisher = new Publisher(publishOptions);
publisher.PublishAsync();
Log.Info("DEMO CUSTOMIZATION : Published item " + args.Item.Name + " with id: " + args.Item.ID, this);
}
public async Task Handle(ProcessClientOutboxMessageCommandV2 message, IMessageHandlerContext context)
{
var clientOutboxMessageId = Guid.Parse(context.MessageId);
var clientOutboxMessage = await _clientOutboxStorage.GetAsync(clientOutboxMessageId, context.SynchronizedStorageSession);
var tasks = clientOutboxMessage.TransportOperations.Select(o =>
{
var publishOptions = new PublishOptions();
publishOptions.SetMessageId(o.MessageId.ToString());
return(context.Publish(o.Message, publishOptions));
});
await Task.WhenAll(tasks);
await _clientOutboxStorage.SetAsDispatchedAsync(clientOutboxMessage.MessageId, context.SynchronizedStorageSession);
}
private List <ManifestFile> GetManifestFiles(List <ManifestFile> onlineManifestFileEntries,
PublishOptions options)
{
if (onlineManifestFileEntries == null || !onlineManifestFileEntries.Any())
{
List <ManifestFile> files = new List <ManifestFile>();
AddDefaultManifestFileEntry(files, options);
return(files);
}
if (!ContainsDefaultEnty(onlineManifestFileEntries, options))
{
AddDefaultManifestFileEntry(onlineManifestFileEntries, options);
return(onlineManifestFileEntries);
}
return(onlineManifestFileEntries);
}
public void TestInvalidBuilderArgs()
{
Assert.Throws <ArgumentException>(() => PublishOptions.Builder().
WithMessageId("").
Build());
Assert.Throws <ArgumentException>(() => PublishOptions.Builder().
WithStream("stream.*").
Build());
Assert.Throws <ArgumentException>(() => PublishOptions.Builder().
WithStream("stream.>").
Build());
Assert.Throws <ArgumentException>(() => PublishOptions.Builder().
WithStream("stream.one").
Build());
}
private static PublishOptions GetPublishOptions(InvocationDetails invocationDetails, PublishOptions publishOptions)
{
PublishOptions result = publishOptions ?? mDefaultPublishOptions;
if (result.DiscloseMe == true)
{
PublishOptionsExtended extended = new PublishOptionsExtended(result);
result = extended;
extended.PublisherId = (long)invocationDetails.Caller;
extended.AuthenticationId = invocationDetails.CallerAuthenticationId;
extended.AuthenticationRole = invocationDetails.CallerAuthenticationRole;
}
result.Acknowledge = null;
result.ExcludeMe = null;
return(result);
}
public Task Publish(IFullMessage[] messages)
{
var options = new PublishOptions();
_metrics.Mark("Dispatched Messages", Unit.Message);
// Todo: publish would only be called for messages on a single stream
// we can set a routing key somehow for BulkMessage so its routed to the same sharded queue
var message = new BulkMessage
{
Messages = messages
};
// Publishing an IMessage normally creates a warning
options.DoNotEnforceBestPractices();
return(Bus.Instance.Publish(message, options));
}
public async Task Handle(PlaceOrder message, IMessageHandlerContext context)
{
log.Info($"Received PlaceOrder, OrderId = {message.OrderId}");
var orderPlaced = new OrderPlaced
{
OrderId = message.OrderId,
ClientId = message.ClientId
};
var publishOptions = new PublishOptions();
publishOptions.SetHeader("insider", GetInsiderProgramValue(message));
publishOptions.SetHeader("membership", GetMembership(message));
// -- Echange : amq.topic, Queue : Syeremy-Messages-Events-OrderPlaced -- binding needed.
await context.Publish(orderPlaced, publishOptions);
}
public void TestMessagePublishWithHeadersAndSubtopics()
{
SetLatch();
SetMessage();
SetHeaders();
string subtopic = "foo.bar";
SubscriptionOptions subscriptionOptions = new SubscriptionOptions();
subscriptionOptions.Subtopic = subtopic;
channel = Backendless.Messaging.Subscribe(TEST_CHANNEL);
channel.AddMessageListener <Message>((resultMessage) =>
{
if (resultMessage.MessageId.Equals(messageStatus.MessageId))
{
Assert.AreEqual(message, resultMessage.Data, "Server returned a message with a wrong message data");
foreach (var key in PublishTest.headers.Keys)
{
Assert.IsTrue(resultMessage.Headers.ContainsKey(key),
"Server returned a message with wrong headers");
Assert.IsTrue(resultMessage.Headers[key].Equals(PublishTest.headers[key]),
"Server returned a message with wrong headers");
}
}
});
PublishOptions publishOptions = new PublishOptions();
publishOptions.Headers = headers;
publishOptions.Subtopic = subtopic;
messageStatus = Backendless.Messaging.Publish(message, TEST_CHANNEL, publishOptions);
Assert.IsNotNull(messageStatus.MessageId, "Server didn't set a messageId for the message");
Assert.IsTrue(messageStatus.Status.Equals(PublishStatusEnum.PUBLISHED),
"Message status was not set as published");
Await();
CheckResult();
}
public CommandLineParserTests(ITestOutputHelper output)
{
_output = output;
_parser = CommandLineParser.Create(
new ServiceCollection(),
startServer: (options, invocationContext) =>
{
_startOptions = options;
},
demo: (options, console, context, startOptions) =>
{
_demoOptions = options;
return(Task.CompletedTask);
},
tryGithub: (options, c) =>
{
_tryGitHubOptions = options;
return(Task.CompletedTask);
},
pack: (options, console) =>
{
_packOptions = options;
return(Task.CompletedTask);
},
install: (options, console) =>
{
_installOptions = options;
_installPackageSource = options.AddSource;
return(Task.CompletedTask);
},
verify: (options, console, startupOptions) =>
{
_verifyOptions = options;
return(Task.FromResult(0));
},
telemetry: new FakeTelemetry(),
publish: (options, console, startupOptions) =>
{
_publishOptions = options;
return(Task.FromResult(0));
},
firstTimeUseNoticeSentinel: new NopFirstTimeUseNoticeSentinel());
}
public void ShouldShallowCloneContext()
{
var message = new OutgoingLogicalMessage(typeof(object), new object());
var options = new PublishOptions();
options.Context.Set("someKey", "someValue");
var testee = new OutgoingPublishContext(message, "message-id", options.OutgoingHeaders, options.Context, new FakeRootContext());
testee.Extensions.Set("someKey", "updatedValue");
testee.Extensions.Set("anotherKey", "anotherValue");
options.Context.TryGet("someKey", out string value);
Assert.AreEqual("someValue", value);
Assert.IsFalse(options.Context.TryGet("anotherKey", out string _));
testee.Extensions.TryGet("someKey", out string updatedValue);
testee.Extensions.TryGet("anotherKey", out string anotherValue2);
Assert.AreEqual("updatedValue", updatedValue);
Assert.AreEqual("anotherValue", anotherValue2);
}
/// <summary>
/// Publish the item
/// </summary>
/// <param name="item"></param>
public static void Publish(this Item item)
{
var publishOptions = new PublishOptions(item.Database,
Database.GetDatabase("web"),
PublishMode.SingleItem,
item.Language,
DateTime.Now); // Create a publisher with the publishoptions
var publisher = new Publisher(publishOptions);
// Choose where to publish from
publisher.Options.RootItem = item;
// Publish children as well?
publisher.Options.Deep = true;
// Do the publish!
publisher.Publish();
}
public IEnumerable <RemoteObserver> GetRelevantSubscribers(PublishOptions options)
{
ImmutableHashSet <RemoteObserver> result = mRemoteObservers;
result = GetEligibleObservers(result, options);
bool excludeMe = options.ExcludeMe ?? true;
PublishOptionsExtended casted = options as PublishOptionsExtended;
if (excludeMe && casted != null)
{
result = result.Remove(new RemoteObserver(casted.PublisherId));
}
result = RemoveExcludedObservers(result, options);
return(result);
}
static private MessageStatus PublishMessageAsPushNotificationSync(string message)
{
var publishOptions = new PublishOptions();
publishOptions.Headers = new Dictionary <string, string>()
{
{ "android-content-title", "Notification title for Android" },
{ "android-content-text", "Notification text for Android" },
{ "android-ticker-text", "ticker" },
{ "ios-badge", "bage" },
};
//DeliveryOptions deliveryOptions = new DeliveryOptions() {PushPolicy = PushPolicyEnum.ALSO, PushBroadcast = 1};
DeliveryOptions deliveryOptions = new DeliveryOptions()
{
PushPolicy = PushPolicyEnum.ONLY, PushBroadcast = 0
};
var deviceId = "7afaed6e-ff92-47e5-ba42-18f91c02fbcb";
deliveryOptions.PushSinglecast = new List <string>()
{
deviceId
};
// deliveryOptions.SetPushBroadcast(PushBroadcastMask.ANDROID | PushBroadcastMask.IOS);
MessageStatus messageStatus = Backendless.Messaging.Publish("Specific Message",
message,
publishOptions
);
if (messageStatus.ErrorMessage == null)
{
Console.WriteLine($"MessageStatus = {messageStatus.Status} Id {messageStatus.MessageId}");
MessageStatus updatedStatus = Backendless.Messaging.GetMessageStatus(messageStatus.MessageId);
return(messageStatus);
}
else
{
Console.WriteLine($"Server reported an error: {messageStatus.ErrorMessage}");
return(null);
}
}
public override void Execute()
{
DacPackage dacpac = DacPackage.Load(this.Parameters.PackageFilePath);
PublishOptions publishOptions = new PublishOptions();
publishOptions.GenerateDeploymentReport = this.Parameters.GenerateDeploymentReport;
publishOptions.CancelToken = this.CancellationToken;
publishOptions.DeployOptions = this.GetDefaultDeployOptions();
publishOptions.DatabaseScriptPath = this.Parameters.ScriptFilePath;
// master script is only used if the target is Azure SQL db and the script contains all operations that must be done against the master database
publishOptions.MasterDbScriptPath = Path.Combine(Path.GetDirectoryName(this.Parameters.ScriptFilePath), string.Concat("master_", Path.GetFileName(this.Parameters.ScriptFilePath)));
PublishResult result = this.DacServices.Script(dacpac, this.Parameters.DatabaseName, publishOptions);
if (this.Parameters.GenerateDeploymentReport && !string.IsNullOrEmpty(this.Parameters.DeploymentReportFilePath))
{
File.WriteAllText(this.Parameters.DeploymentReportFilePath, result.DeploymentReport);
}
}
public void Publish(TransportMessage message, PublishOptions publishOptions)
{
dynamic channel;
if (ChannelProvider.TryGetPublishChannel(out channel))
{
PublishMessage(message,publishOptions,channel);
}
else
{
using (var confirmsAwareChannel = ChannelProvider.GetNewPublishChannel())
{
PublishMessage(message, publishOptions, confirmsAwareChannel.Channel);
}
}
}
public TDelegate CreatePositionalDelegate <TDelegate>(IWampTopicProxy proxy, PublishOptions publishOptions)
{
// Writes: topicProxy.Publish(publishOptions,
// new object[]
// {
// (object)arg1,
// (object)arg2,
// ...,
// (object)argn
// });
Func <ParameterExpression[], Expression> callExpression = parameters =>
Expression.Call(Expression.Constant(proxy), mPublishPositionalMethod,
Expression.Constant(publishOptions),
Expression.NewArrayInit(typeof(object),
parameters.Select(x => Expression.Convert(x, typeof(object)))));
return(InnerCreateDelegate <TDelegate>(callExpression));
}
private void RunPublishJob(Item item, Database sourceDatabase, Database targetDatabase, PublishMode publishMode, Language language, bool deep)
{
var options = new PublishOptions(sourceDatabase, targetDatabase, publishMode, language, DateTime.Now)
{
Deep = deep,
PublishRelatedItems = false,
RootItem = item
};
try
{
var publisher = new Publisher(options);
publisher.Publish();
}
catch (Exception ex)
{
Sitecore.Diagnostics.Log.Error("Error publishing.", ex, this);
}
}
public async Task WhenPublishingMessagesWithCustomHeaders_HeadersCanBeReadOnSubscriberSide()
{
const string HeaderKey = "MyHeader";
const string HeaderValue = "MyValue";
var publishOptions = new PublishOptions();
publishOptions.Headers.Add(HeaderKey, HeaderValue);
await publisher.Publish(new Event
{
Bar = 42
}, publishOptions);
context.SecondHandlerCaughtHeaders.Should()
.Contain(HeaderKey, HeaderValue);
context.FirstcHandlerCaughtHeaders.Should()
.Contain(HeaderKey, HeaderValue);
}
public string Publish(string sourceDatabaseName, string[] targetNames = null, string[] languageNames = null)
{
using (new SecurityDisabler())
{
var sourceDatabase = Factory.GetDatabase(sourceDatabaseName);
var languages = LanguageManager.GetLanguages(sourceDatabase).AsEnumerable();
if (languageNames != null && languageNames.Length > 0)
{
languages = languages.Where(l => languageNames.Contains(l.Name));
}
var targets = PublishManager.GetPublishingTargets(sourceDatabase).AsEnumerable();
var targetDatabases = new List<Database>();
if (targetNames != null && targetNames.Length > 0)
{
targets = targets.Where(t => targetNames.Contains(t.Name));
}
foreach (var target in targets)
{
targetDatabases.Add(Factory.GetDatabase(target["Target database"]));
}
var publishOptions = new PublishOptions(
sourceDatabase,
targetDatabases.First(),
PublishMode.Smart,
languages.First(),
DateTime.Now,
targetNames.ToList())
{
Deep = true,
RootItem = sourceDatabase.Items["/sitecore"]
};
var publisher = new Sitecore.Publishing.Publisher(publishOptions, languages);
var job = publisher.PublishAsync();
return job.Name;
}
}
public async Task Handle(BookRentalCarCommand message, IMessageHandlerContext context)
{
lock (Console.Out)
{
if (context is IMessageBrokerContext messageBrokerContext)
{
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine($"Received '{message.GetType().Name}' command from message broker. Message Id: '{messageBrokerContext.BrokeredMessage.MessageId}', Subscription: '{messageBrokerContext.BrokeredMessage.MessageReceiverPath}'");
}
else
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"Received '{message.GetType().Name}' command from local dispatcher");
}
Console.WriteLine($"Command Data: {JsonConvert.SerializeObject(message)}");
Console.ResetColor();
}
var carRental = new Domain.Aggregates.CarRental(); //TODO: just an example - likely more properties would be passed in via ctor
var reservationId = carRental.Reserve(message.Car.Airport, message.Car.Vendor, message.Car.From, message.Car.Until);
await _repository.AddAsync(carRental);
var integrationEvents = _eventMapper.MapAll(carRental.DomainEvents);
//throw new Exception("without using the outbox, we're in a bad state. aggregate has been saved, integration events will never be published.");
foreach (var ie in integrationEvents)
{
var options = new PublishOptions()
{
MessageId = Guid.NewGuid().ToString()
};
await _brokeredMessageDispatcher.Publish(ie, context.GetTransactionContext(), options : options);
lock (Console.Out)
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine($"Dispatched domain event: {JsonConvert.SerializeObject(ie)}");
Console.ResetColor();
}
}
}
public Task Handle(PlaceOrder message, IMessageHandlerContext context)
{
logger.Info($"Received PlaceOrder, OrderId = {message.OrderId}");
// This is normally where some business logic would occur
var orderPlaced = new OrderPlaced
{
OrderId = message.OrderId,
ClientId = message.ClientId
};
var publishOptions = new PublishOptions();
publishOptions.SetHeader("insider", GetInsiderProgramValue(message));
publishOptions.SetHeader("membership", GetMembership(message));
return(context.Publish(orderPlaced, publishOptions));
}
public Task Should_allow_publishing_commands()
{
return(Scenario.Define <ScenarioContext>()
.WithEndpoint <Endpoint>(b => b.When((session, c) =>
{
var publishOptions = new PublishOptions();
publishOptions.DoNotEnforceBestPractices();
return session.Publish(new MyCommand(), publishOptions);
}))
.Done(c => c.EndpointsStarted)
// This test is only relevant for message driven transports since we need to use the mappings to
// configure the publisher. The code first API would blow up unless we turn off the checks for the entire endpoint.
// But if we do that turning off checks per message becomes pointless since they are already off.
// We would need a new api to turn off startup checks only for this to be testable across the board.
.Repeat(r => r.For <AllTransportsWithMessageDrivenPubSub>())
.Should(c => Assert.True(c.EndpointsStarted))
.Run());
}
public async Task Handle(InitiatingMessage message, IMessageHandlerContext context)
{
//HINT: this scope is never completed
using (new System.Transactions.TransactionScope(TransactionScopeOption.RequiresNew, TransactionScopeAsyncFlowOption.Enabled))
{
using (var connection = new SqlConnection(ConnectionString))
{
connection.Open();
var sendOptions = new SendOptions();
sendOptions.UseCustomSqlConnection(connection);
sendOptions.RouteToThisEndpoint();
await context.Send(new FollowUpRolledbackCommand(), sendOptions);
var publishOptions = new PublishOptions();
publishOptions.UseCustomSqlConnection(connection);
await context.Publish(new FollowUpRolledbackEvent(), publishOptions);
}
}
using (var scope = new System.Transactions.TransactionScope(TransactionScopeOption.RequiresNew, TransactionScopeAsyncFlowOption.Enabled))
{
using (var connection = new SqlConnection(ConnectionString))
{
connection.Open();
var sendOptions = new SendOptions();
sendOptions.UseCustomSqlConnection(connection);
sendOptions.RouteToThisEndpoint();
await context.Send(new FollowUpCompletedCommand(), sendOptions);
var publishOptions = new PublishOptions();
publishOptions.UseCustomSqlConnection(connection);
await context.Publish(new FollowUpCompletedEvent(), publishOptions);
scenarioContext.InHandlerTransactionEscalatedToDTC = Transaction.Current.TransactionInformation.DistributedIdentifier != Guid.Empty;
}
scope.Complete();
}
throw new Exception("This should NOT prevent the InitiatingMessage from failing.");
}
public async Task Handle(MyMessage message, IMessageHandlerContext context)
{
var sendOptions = new SendOptions();
sendOptions.SetHeader("MyCustomHeader", "My custom value");
await context.Send(new SomeOtherMessage(), sendOptions)
.ConfigureAwait(false);
var replyOptions = new ReplyOptions();
replyOptions.SetHeader("MyCustomHeader", "My custom value");
await context.Reply(new SomeOtherMessage(), replyOptions)
.ConfigureAwait(false);
var publishOptions = new PublishOptions();
publishOptions.SetHeader("MyCustomHeader", "My custom value");
await context.Publish(new SomeOtherMessage(), publishOptions)
.ConfigureAwait(false);
}
public void ShouldShallowCloneContext()
{
var message = new OutgoingLogicalMessage(typeof(object), new object());
var options = new PublishOptions();
options.Context.Set("someKey", "someValue");
var testee = new OutgoingPublishContext(message, options, new RootContext(null, null, null));
testee.Extensions.Set("someKey", "updatedValue");
testee.Extensions.Set("anotherKey", "anotherValue");
string value;
string anotherValue;
options.Context.TryGet("someKey", out value);
Assert.AreEqual("someValue", value);
Assert.IsFalse(options.Context.TryGet("anotherKey", out anotherValue));
string updatedValue;
string anotherValue2;
testee.Extensions.TryGet("someKey", out updatedValue);
testee.Extensions.TryGet("anotherKey", out anotherValue2);
Assert.AreEqual("updatedValue", updatedValue);
Assert.AreEqual("anotherValue", anotherValue2);
}
public static List<Item> GetRows(Database sourceDb, Database targetDb, int maximumRows, int startRowIndex, int pageSize)
{
List<Item> queuedItems = new List<Item>();
// TODO: dynamically set language
DateTime publishDate = DateTime.Now;
PublishOptions options = new PublishOptions(sourceDb, targetDb, PublishMode.Incremental, Language.Parse("en"), publishDate);
IEnumerable<PublishingCandidate> candidates = PublishQueue.GetPublishQueue(options);
foreach (PublishingCandidate candidate in candidates)
{
Item item = sourceDb.GetItem(candidate.ItemId);
if (item != null)
{
item = item.Publishing.GetValidVersion(publishDate, true);
if (item != null && item.Access.CanRead() && item.Access.CanReadLanguage() && item.Access.CanWriteLanguage() && ((Sitecore.Context.IsAdministrator || item.Locking.CanLock()) || item.Locking.HasLock()))
{
queuedItems.Add(item);
}
}
}
_rowCount = queuedItems.Count;
return queuedItems.Skip(startRowIndex).Take(pageSize).ToList();
}
/// <summary>
/// Publishes item to all publication databases
/// </summary>
/// <param name="item">Sitecore Item to publish</param>
/// <param name="publishMode">Sitecore publish mode</param>
public static void PublishItem(Item item, PublishMode publishMode = PublishMode.SingleItem)
{
if (masterDB != null && publicationDBs != null && publicationDBs.Count > 0)
{
var itemPublishToPublicationDatabasesOptionsArray = new PublishOptions[publicationDBs.Count][];
for (int i = 0; i < publicationDBs.Count; i++)
{
itemPublishToPublicationDatabasesOptionsArray[i] = new PublishOptions[masterDB.Languages.Length];
for (var j = 0; j < masterDB.Languages.Length; j++)
{
itemPublishToPublicationDatabasesOptionsArray[i][j] = new PublishOptions(masterDB, publicationDBs[i], publishMode, masterDB.Languages[j], DateTime.Now)
{
Deep = true,
CompareRevisions = true,
RootItem = item,
};
}
PublishManager.Publish(itemPublishToPublicationDatabasesOptionsArray[i]);
}
}
}
/// <summary>Publish data to CMS.</summary>
/// <param name="item">Data item.</param>
/// <param name="language">Date item language.</param>
/// <param name="dbMaster">Database source.</param>
/// <param name="dbWeb">Database target.</param>
public void PublishData(Sitecore.Data.Items.Item item, Sitecore.Globalization.Language language, Sitecore.Data.Database dbMaster, Sitecore.Data.Database dbWeb)
{
// Use CMS security disabler to allow changes.
using(new SecurityDisabler()) {
PublishOptions opt = new PublishOptions(dbMaster, dbWeb, PublishMode.SingleItem, language, DateTime.Now);
opt.RootItem = item;
opt.Deep = false;
Publisher pub = new Publisher(opt);
pub.Publish();
}
}
public Task PublishAsync(TransportMessage message, PublishOptions options)
{
var brokeredMessage = message.ToBrokeredMessage();
var transportMessage = new TransportMessage(brokeredMessage);
return this.onMessage(transportMessage);
}
public Task Publish(object message, PublishOptions options = null)
{
return this.unit.Publish(message, options);
}
private IEnumerable<ID> GetRelatedItemIDs(PublishOptions options)
{
IEnumerable<ID> publishQueueItems = GetPublishQueueItems(options);
return publishQueueItems.SelectMany(GetReferences).ToArray();
}
private IEnumerable<ID> GetPublishQueueItems(PublishOptions options)
{
if (options.Mode == PublishMode.Incremental)
return PublishQueue.GetPublishQueue(options).Select(candidate => candidate.ItemId).ToArray();
return PublishQueue.GetContentBranch(options).Select(candidate => candidate.ItemId).ToArray();
}
/// <summary>
/// Creates a stream of items that are candidates for publishing
/// </summary>
protected override ISourceObservable<CandidateValidationContext> CreatePublishSourceStream(DateTime started, PublishOptions options, IPublishCandidateSource publishSourceRepository, IPublishValidator validator, IPublisherOperationService publisherOperationService, CancellationTokenSource errorSource)
{
IPublishCandidate result = publishSourceRepository.GetNode(options.ItemId.Value).Result;
if (result == null)
throw new ArgumentNullException(string.Format("The publish could not be performed from a start item that doesn't exist : {0}.", (object) options.ItemId.Value));
IPublishCandidate publishCandidate = result.ParentId.HasValue ?
publishSourceRepository.GetNode(result.ParentId.Value).Result :
result;
ISourceObservable<CandidateValidationContext> sourceObservable =
(ISourceObservable<CandidateValidationContext>) new TreeNodeSourceProducer(
publishSourceRepository,
result,
validator,
options.Descendants,
this._options.SourceTreeReaderBatchSize,
errorSource,
(ILogger) LoggerFactoryExtensions.CreateLogger<TreeNodeSourceProducer>(this._loggerFactory));
if (PublishOptionsMetadataExtensions.GetItemBucketsEnabled(options) && publishCandidate.Node.TemplateId == PublishOptionsMetadataExtensions.GetBucketTemplateId(options))
sourceObservable =
(ISourceObservable<CandidateValidationContext>) new BucketNodeSourceProducer(
sourceObservable,
publishSourceRepository,
result,
PublishOptionsMetadataExtensions.GetBucketTemplateId(options),
errorSource,
(ILogger) LoggerFactoryExtensions.CreateLogger<BucketNodeSourceProducer>(this._loggerFactory));
DeletedNodesSourceProducer dnsp = new DeletedNodesSourceProducer(
sourceObservable,
started,
options.Languages,
options.Targets,
(IEnumerable<string>)new string[1] { PublishOptionsMetadataExtensions.GetPublishType(options) },
publisherOperationService,
this._options.UnpublishedOperationsLoadingBatchSize,
errorSource,
(ILogger)LoggerFactoryExtensions.CreateLogger<UnpublishedNodeSourceProducer>(this._loggerFactory),
(Predicate<PublisherOperation>)(op => Enumerable.Contains<Guid>((IEnumerable<Guid>)op.Path.Ancestors, options.ItemId.Value)));
return (ISourceObservable<CandidateValidationContext>)dnsp;
}
public static void PublishItem(Item item, Database database)
{
PublishOptions publishOptions = new PublishOptions
(
item.Database,
database,
Sitecore.Publishing.PublishMode.SingleItem,
item.Language,
DateTime.Now
);
Publisher publisher = new Publisher(publishOptions);
publisher.Options.RootItem = item;
publisher.Publish();
}
// Methods
private IEnumerable<PublishingCandidate> GetSourceItems(PublishOptions options)
{
if (options.Mode == PublishMode.Incremental)
{
return PublishQueue.GetPublishQueue(options);
}
return PublishQueue.GetContentBranch(options);
}
/// <summary>
/// Returns the additional items to be published from the velir images field
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public List<PublishingCandidate> GetAdditionalPublishingCandidates(PublishContext context)
{
List<PublishingCandidate> additionalItems = new List<PublishingCandidate>();
Item item = context.PublishOptions.RootItem;
TemplateItem template = item.Template;
foreach (TemplateFieldItem field in template.Fields)
{
//verify not a standard/system field
if (field.InnerItem.IsNotNull() && field.InnerItem.Paths.FullPath.ToLower().StartsWith("/sitecore/templates/system"))
{
continue;
}
//get field value
string fieldValue = item[field.Name];
if (string.IsNullOrEmpty(fieldValue))
{
continue;
}
//split into guid array
string[] values = fieldValue.Split('|');
if (values.Length == 0)
{
continue;
}
foreach (string fieldValueItemId in values)
{
if (string.IsNullOrEmpty(fieldValueItemId))
{
continue;
}
ID additionalItemId;
if (!ID.TryParse(fieldValueItemId, out additionalItemId))
{
continue;
}
PublishOptions options = new PublishOptions(context.PublishOptions.SourceDatabase,
context.PublishOptions.TargetDatabase,
PublishMode.Smart,
item.Language, context.PublishOptions.PublishDate);
PublishingCandidate publishingCandidate = new PublishingCandidate(additionalItemId, options);
additionalItems.Add(publishingCandidate);
}
}
return additionalItems;
}
private void PublishToTarget(Item item, Database source, Database target)
{
if (PublishMode == PublishMode.Unknown)
{
PublishMode = PublishMode.Smart;
}
var language = item.Language;
if (ShouldProcess(item.GetProviderPath(),
string.Format("{3}ublishing language '{0}', version '{1}' to target '{2}'.", language, item.Version,
target.Name, Recurse.IsPresent ? "Recursively p" : "P")))
{
WriteVerbose(
String.Format(
"Publishing item '{0}' in language '{1}', version '{2}' to target '{3}'. (Recurse={4}).",
item.Name, language, item.Version, target.Name, Recurse.IsPresent));
var options = new PublishOptions(source, target, PublishMode, language, DateTime.Now)
{
Deep = Recurse.IsPresent,
RootItem = item
};
var optionsArgs = new PublishOptions[1];
optionsArgs[0] = options;
var handle = PublishManager.Publish(optionsArgs);
if (handle != null)
{
var publishStatus = PublishManager.GetStatus(handle) ?? new PublishStatus();
WriteVerbose(String.Format("Publish Job submitted, current state={0}.",
publishStatus.State));
}
}
}
