private async Task SendMessageAsync(Mocks.CloudBlobStorageProviderMock cloudStorage, Mocks.InboxHttpHandlerMock inboxMock, CryptoSettings senderCrypto, OwnEndpoint senderEndpoint, Endpoint receiverEndpoint)
{
Requires.NotNull(cloudStorage, "cloudStorage");
Requires.NotNull(senderCrypto, "senderCrypto");
Requires.NotNull(senderEndpoint, "senderEndpoint");
Requires.NotNull(receiverEndpoint, "receiverEndpoint");
var httpHandler = new Mocks.HttpMessageHandlerMock();
cloudStorage.AddHttpHandler(httpHandler);
inboxMock.Register(httpHandler);
var sentMessage = Valid.Message;
var channel = new Channel()
{
HttpClient = new HttpClient(httpHandler),
CloudBlobStorage = cloudStorage,
CryptoServices = senderCrypto,
Endpoint = senderEndpoint,
Logger = this.logger,
};
await channel.PostAsync(sentMessage, new[] { receiverEndpoint }, Valid.ExpirationUtc);
}
public void DefaultContactCtor() {
var contact = new Endpoint();
Assert.That(contact.MessageReceivingEndpoint, Is.Null);
Assert.That(contact.EncryptionKeyPublicMaterial, Is.Null);
Assert.That(contact.SigningKeyPublicMaterial, Is.Null);
Assert.That(contact.CreatedOnUtc, Is.EqualTo(DateTime.UtcNow).Within(TimeSpan.FromMinutes(1)));
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="endpoint"></param>
public RemoteServiceInterceptor(Endpoint endpoint)
: this(endpoint
, endpoint.Resolve<ILoggerFactory>()
, endpoint.Resolve<ISerializer>()
, endpoint.Resolve<ILoadBalancingHelper>())
{
}
public Binding Create(Endpoint serviceInterface)
{
var binding = new BasicHttpBinding
{
Name = serviceInterface.EndpointName,
AllowCookies = false,
HostNameComparisonMode = serviceInterface.HostNameComparisonMode.ParseAsEnum(HostNameComparisonMode.StrongWildcard),
MaxBufferPoolSize = serviceInterface.MaxBufferPoolSize,
MaxReceivedMessageSize = serviceInterface.MaxReceivedSize,
MessageEncoding = serviceInterface.MessageFormat.ParseAsEnum(WSMessageEncoding.Mtom),
MaxBufferSize = serviceInterface.MaxBufferSize,
TransferMode = TransferMode.Streamed,
TextEncoding = Encoding.UTF8,
ReaderQuotas = XmlDictionaryReaderQuotas.Max,
BypassProxyOnLocal = true,
UseDefaultWebProxy = false,
};
if (ConfigurationManagerHelper.GetValueOnKey("stardust.UseDefaultProxy") == "true")
{
binding.BypassProxyOnLocal = false;
binding.UseDefaultWebProxy = true;
}
return binding;
}
public Binding Create(Endpoint serviceInterface)
{
System.Net.ServicePointManager.ServerCertificateValidationCallback =
((sender, certificate, chain, sslPolicyErrors) => true);
var secureBinding = new WS2007FederationHttpBinding(WSFederationHttpSecurityMode.TransportWithMessageCredential)
{
Name = "secure",
TransactionFlow = false,
HostNameComparisonMode = serviceInterface.HostNameComparisonMode.ParseAsEnum(HostNameComparisonMode.StrongWildcard),
MaxBufferPoolSize = serviceInterface.MaxBufferPoolSize,
MaxReceivedMessageSize = serviceInterface.MaxReceivedSize,
MessageEncoding = serviceInterface.MessageFormat.ParseAsEnum(WSMessageEncoding.Text),
TextEncoding = Encoding.UTF8,
ReaderQuotas = XmlDictionaryReaderQuotas.Max,
BypassProxyOnLocal = true,
UseDefaultWebProxy = false
};
if (ConfigurationManagerHelper.GetValueOnKey("stardust.UseDefaultProxy")=="true")
{
secureBinding.BypassProxyOnLocal = false;
secureBinding.UseDefaultWebProxy = true;
}
SetSecuritySettings(serviceInterface, secureBinding);
return secureBinding;
}
public void Configure(AbstractRhinoServiceBusConfiguration config, IBusContainerBuilder builder, IServiceLocator locator)
{
var busConfig = config as RhinoServiceBusConfiguration;
if (busConfig == null)
return;
var busElement = config.ConfigurationSection.Bus;
if (busElement == null)
return;
var loadBalancerEndpointAsString = busElement.LoadBalancerEndpoint;
if (string.IsNullOrEmpty(loadBalancerEndpointAsString))
return;
Uri loadBalancerEndpoint;
if (!Uri.TryCreate(loadBalancerEndpointAsString, UriKind.Absolute, out loadBalancerEndpoint))
throw new ConfigurationErrorsException(
"Attribute 'loadBalancerEndpoint' on 'bus' has an invalid value '" + loadBalancerEndpointAsString + "'");
var endpoint = new Endpoint { Uri = loadBalancerEndpoint };
builder.RegisterLoadBalancerEndpoint(endpoint.Uri);
config.AddMessageModule<LoadBalancerMessageModule>();
}
public HttpResponseMessage Put(Endpoint endpoint)
{
try
{
if (endpoint == null)
throw WebException(Constants.ErrorParameterEndpointCannotBeNull, HttpStatusCode.BadRequest);
// Set the username under which the app will store the channel
endpoint.UserId = this.mapUsernameDelegate(this.Request);
if (endpoint.ExpirationTime == null || endpoint.ExpirationTime == DateTime.MinValue)
endpoint.ExpirationTime = DateTime.UtcNow.Add(defaultEndpointExpirationTime);
this.Repository.InsertOrUpdate(endpoint);
return new HttpResponseMessage(HttpStatusCode.Accepted);
}
catch (HttpResponseException)
{
throw;
}
catch (Exception exception)
{
throw WebException(exception.Message, HttpStatusCode.InternalServerError);
}
}
public Binding Create(Endpoint serviceInterface)
{
if (Utilities.Utilities.GetDisableCertificateValidation().EqualsCaseInsensitive("true"))
System.Net.ServicePointManager.ServerCertificateValidationCallback =
((sender, certificate, chain, sslPolicyErrors) => true);
var binding = new BasicHttpBinding(BasicHttpSecurityMode.Transport)
{
Name = serviceInterface.EndpointName,
AllowCookies = false,
HostNameComparisonMode = serviceInterface.HostNameComparisonMode.ParseAsEnum(HostNameComparisonMode.StrongWildcard),
MaxBufferPoolSize = serviceInterface.MaxBufferPoolSize,
MaxReceivedMessageSize = serviceInterface.MaxReceivedSize,
MessageEncoding = serviceInterface.MessageFormat.ParseAsEnum(WSMessageEncoding.Text),
TextEncoding = Encoding.UTF8,
ReaderQuotas = XmlDictionaryReaderQuotas.Max,
BypassProxyOnLocal = true,
UseDefaultWebProxy = false
};
if (ConfigurationManagerHelper.GetValueOnKey("stardust.UseDefaultProxy") == "true")
{
binding.BypassProxyOnLocal = false;
binding.UseDefaultWebProxy = true;
}
binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Windows;
return binding;
}
public void EndpointSendAndReceive()
{
using (var management = new RabbitMqEndpointManagement(_queue))
{
management.BindQueue(_queue.Name, _exchange.Name, ExchangeType.Fanout, "", null);
}
IMessageSerializer serializer = new XmlMessageSerializer();
var message = new BugsBunny {Food = "Carrot"};
IDuplexTransport transport = _factory.BuildLoopback(new TransportSettings(_exchange));
IOutboundTransport error = _factory.BuildError(new TransportSettings(_error));
var sendEndpoint = new Endpoint(_exchange, serializer, transport, error,
new InMemoryInboundMessageTracker(5));
sendEndpoint.Send(message);
var receiveEndpoint = new Endpoint(_queue, serializer, transport, error,
new InMemoryInboundMessageTracker(5));
receiveEndpoint.Receive(o =>
{
return b =>
{
var bb = (BugsBunny)b;
Console.WriteLine(bb.Food);
};
}, TimeSpan.Zero);
}
public static void Test(ITransport t, IQueueStrategy strategy,
Endpoint queueEndpoint, Action<Message> send, Func<MessageEnumerator>
enumer)
{
Guid id = Guid.NewGuid();
var serializer = new XmlMessageSerializer(new
DefaultReflection(), new DefaultKernel());
var subscriptionStorage = new MsmqSubscriptionStorage(new
DefaultReflection(),
serializer,
queueEndpoint.Uri,
new
EndpointRouter(),
strategy);
subscriptionStorage.Initialize();
var wait = new ManualResetEvent(false);
subscriptionStorage.SubscriptionChanged += () => wait.Set();
t.AdministrativeMessageArrived +=
subscriptionStorage.HandleAdministrativeMessage;
Message msg = new MessageBuilder
(serializer).GenerateMsmqMessageFromMessageBatch(new
AddInstanceSubscription
{
Endpoint = queueEndpoint.Uri.ToString(),
InstanceSubscriptionKey = id,
Type = typeof (TestMessage2).FullName,
});
send(msg);
wait.WaitOne();
msg = new MessageBuilder
(serializer).GenerateMsmqMessageFromMessageBatch(new
RemoveInstanceSubscription
{
Endpoint = queueEndpoint.Uri.ToString(),
InstanceSubscriptionKey = id,
Type = typeof (TestMessage2).FullName,
});
wait.Reset();
send(msg);
wait.WaitOne();
IEnumerable<Uri> uris = subscriptionStorage
.GetSubscriptionsFor(typeof (TestMessage2));
Assert.Equal(0, uris.Count());
int count = 0;
MessageEnumerator copy = enumer();
while (copy.MoveNext()) count++;
Assert.Equal(0, count);
}
public MessageQueue[] InitializeQueue(Endpoint queueEndpoint, QueueType queueType)
{
var queue = MsmqUtil.GetQueuePath(queueEndpoint).Create();
switch (queueType)
{
case QueueType.Standard:
return new[]
{
queue,
MsmqUtil.OpenOrCreateQueue(GetErrorsQueuePath(), QueueAccessMode.SendAndReceive, queue),
MsmqUtil.OpenOrCreateQueue(GetSubscriptionQueuePath(), QueueAccessMode.SendAndReceive, queue),
MsmqUtil.OpenOrCreateQueue(GetDiscardedQueuePath(), QueueAccessMode.SendAndReceive, queue),
MsmqUtil.OpenOrCreateQueue(GetTimeoutQueuePath(), QueueAccessMode.SendAndReceive, queue),
};
case QueueType.LoadBalancer:
return new[]
{
queue,
MsmqUtil.OpenOrCreateQueue(GetKnownWorkersQueuePath(), QueueAccessMode.SendAndReceive, queue),
MsmqUtil.OpenOrCreateQueue(GetKnownEndpointsQueuePath(), QueueAccessMode.SendAndReceive, queue),
};
case QueueType.Raw:
return new[]
{
queue,
};
default:
throw new ArgumentOutOfRangeException("queueType", "Can't handle queue type: " + queueType);
}
}
public static QueueInfo GetQueuePath(Endpoint endpoint)
{
var uri = endpoint.Uri;
if (uri.AbsolutePath.IndexOf("/", 1) >= 0)
{
throw new InvalidOperationException(
"Invalid enpoint url : " + uri + Environment.NewLine +
"Queue Endpoints can't have a child folders (including 'public')" + Environment.NewLine +
"Good: 'msmq://machinename/queue_name'." + Environment.NewLine +
" Bad: msmq://machinename/round_file/queue_name"
);
}
string hostName = uri.Host;
string queuePathWithFlatSubQueue =
uri.AbsolutePath.Substring(1);
if (string.IsNullOrEmpty(uri.Fragment) == false && uri.Fragment.Length > 1)
queuePathWithFlatSubQueue += uri.Fragment;
if (string.Compare(hostName, ".") == 0 ||
string.Compare(hostName, Environment.MachineName, true) == 0 ||
string.Compare(hostName, "localhost", true) == 0)
{
return new QueueInfo
{
IsLocal = true,
QueuePath = Environment.MachineName + @"\private$\" + queuePathWithFlatSubQueue,
QueueUri = uri,
Transactional = endpoint.Transactional
};
}
IPAddress address;
if (IPAddress.TryParse(hostName, out address))
{
return new QueueInfo
{
IsLocal = false,
QueuePath = "FormatName:DIRECT=TCP:" + hostName + @"\private$\" + queuePathWithFlatSubQueue,
QueueUri = uri,
Transactional = endpoint.Transactional
};
}
if (guidRegEx.IsMatch(hostName))
{
return new QueueInfo
{
IsLocal = false,
QueuePath = "FormatName:PRIVATE=" + hostName + @"\" + queuePathWithFlatSubQueue,
QueueUri = uri,
Transactional = endpoint.Transactional
};
}
return new QueueInfo
{
IsLocal = false,
QueuePath = "FormatName:DIRECT=OS:" + hostName + @"\private$\" + queuePathWithFlatSubQueue,
QueueUri = uri,
Transactional = endpoint.Transactional
};
}
public void Run()
{
while (true)
{
var url = Console.ReadLine();
if (url == null)
{
break;
}
url = url.Trim();
if (!string.IsNullOrEmpty(url))
{
try
{
var endPoint = new Endpoint(url);
var output = this.dispatcher.DispatchAction(endPoint);
Console.WriteLine(output);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
}
public MsmqFlatQueueTestBase()
{
defaultTestBase = new MsmqTestBase();
testQueueEndPoint = new Endpoint
{
Uri = new Uri("msmq://localhost/test_queue")
};
testQueuePath = MsmqUtil.GetQueuePath(testQueueEndPoint).QueuePath;
transactionalTestQueueEndpoint = new Endpoint
{
Uri = new Uri("msmq://localhost/transactional_test_queue")
};
transactionalTestQueuePath = MsmqUtil.GetQueuePath(transactionalTestQueueEndpoint).QueuePath;
subscriptionsEndpoint = new Endpoint
{
Uri = new Uri(testQueueEndPoint.Uri + "#" + subscriptions)
};
subscriptionQueuePath = MsmqUtil.GetQueuePath(subscriptionsEndpoint).QueuePath;
SetupQueues();
queue = MsmqUtil.GetQueuePath(testQueueEndPoint).Open();
transactionalQueue = MsmqUtil.GetQueuePath(transactionalTestQueueEndpoint).Open();
subscriptions = MsmqUtil.GetQueuePath(subscriptionsEndpoint).Open(QueueAccessMode.SendAndReceive,
new XmlMessageFormatter(new[]
{
typeof (string)
}));
}
public void SaveEndpoint(Endpoint endpoint)
{
using (var conn = _db.OpenConnection())
using (var tx = conn.BeginTransaction())
{
var tags = endpoint.Metadata.Tags.ToDbString();
conn.Execute(
$"replace into EndpointConfig(MonitorType, Address, GroupName, Name, Id, Password, RegisteredOnUtc, RegistrationUpdatedOnUtc, MonitorTag{(tags != null ? ", Tags" : "")}) values(@MonitorType,@Address,@Group,@Name,@Id,@Password,@RegisteredOnUtc,@RegistrationUpdatedOnUtc,@MonitorTag{(tags != null ? ",@Tags" : "")})",
new
{
endpoint.Identity.MonitorType,
endpoint.Identity.Address,
endpoint.Metadata.Group,
endpoint.Metadata.Name,
endpoint.Identity.Id,
endpoint.Password,
endpoint.Metadata.RegisteredOnUtc,
endpoint.Metadata.RegistrationUpdatedOnUtc,
endpoint.Metadata.MonitorTag,
tags
}, tx);
tx.Commit();
}
}
static void Main(string[] args)
{
LogFactory.BuildLogger = type => new ConsoleWindowLogger(type);
ConsoleWindowLogger.MinimumLogLevel = LogLevel.Info;
var endpoint = new Endpoint();
endpoint.Start();
using (var scope = Settings.RootContainer.BeginLifetimeScope())
{
var dtoCompanyQueryService = scope.GetInstance<DtoCompanyQueryService>();
var dtoEmployeeQueryService = scope.GetInstance<DtoEmployeeQueryService>();
var googlePage = dtoCompanyQueryService
.Query
.Where(c => c.Employees.Any(employee => employee.Name.Contains("Smith")))
.OrderBy(company => company.Name).FetchPage(1, 10);
var firstCompanyDto = dtoCompanyQueryService.Query.First();
var companiesWithMoreThanTwoEmployees = dtoCompanyQueryService.Query.Where(company => company.Employees.Count > 2).ToArray();
var ordered = dtoCompanyQueryService.Query
.OrderByDescending(company => company.Employees.Count)
.ThenByDescending(company => company.Name)
.ToArray();
dtoEmployeeQueryService.Query.FirstOrDefault(employee => employee.Name.Length > 2);
}
}
private EndpointDetails(Endpoint endpoint)
{
Id = endpoint.Identity.Id;
Address = endpoint.Identity.Address;
MonitorType = endpoint.Identity.MonitorType;
Name = endpoint.Metadata.Name;
Group = endpoint.Metadata.Group;
var health = endpoint.Health;
LastModifiedTime = endpoint.LastModifiedTimeUtc;
if (health != null)
{
Status = health.Status;
LastCheckUtc = health.CheckTimeUtc;
LastResponseTime = health.ResponseTime;
Details = health.Details.ToDictionary(p => p.Key, p => p.Value);
}
else
{
Details = new Dictionary<string, string>();
Status = EndpointStatus.NotRun;
}
Tags = endpoint.Metadata.Tags;
RegisteredOnUtc = endpoint.Metadata.RegisteredOnUtc;
RegistrationUpdatedOnUtc = endpoint.Metadata.RegistrationUpdatedOnUtc;
MonitorTag = endpoint.Metadata.MonitorTag;
}
public void Report( Endpoint endpoint, EndpointStatus status )
{
var message = BuildMessage( endpoint, status );
using ( var client = BuildSmtpClient() )
{
client.Send( message );
}
}
public MessageQueue[] InitializeQueue(Endpoint queueEndpoint, QueueType queueType)
{
var path = MsmqUtil.GetQueuePath(queueEndpoint);
return new[]
{
path.Create()
};
}
protected void CreateQueues(QueueType mainQueueType, Endpoint mainQueueEndpoint, string user)
{
// will create the queues if they are not already there
var queues = queueStrategy.InitializeQueue(mainQueueEndpoint, mainQueueType);
foreach (var queue in queues)
{
GrantPermissions(queue, user);
}
}
private async Task MonitorEndpointUpdatesAsync(Endpoint endpoint, CancellationToken cancellationToken)
{
while (!endpoint.IsDisposed && !cancellationToken.IsCancellationRequested)
{
if (WasEndpointUpdateMissed(endpoint))
ReportEndpointTimeout(endpoint);
await _timeCoordinator.Delay(GetEndpointUpdateCheckDelay(endpoint), cancellationToken);
}
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="endpoint"></param>
/// <param name="factory"></param>
/// <param name="serializer"></param>
/// <param name="loadBalancingHelper"></param>
public RemoteServiceInterceptor(Endpoint endpoint
, ILoggerFactory factory
, ISerializer serializer
, ILoadBalancingHelper loadBalancingHelper)
{
this._endpoint = endpoint;
this._log = factory.Create(typeof(RemoteServiceInterceptor));
this._serializer = serializer;
this._loadBalancingHelper = loadBalancingHelper;
}
public AuthenticationFilterTests()
{
_requestCredentials = new Credentials(Guid.NewGuid(), "request");
_adminCredentials = new Credentials(Guid.NewGuid(), "admin");
_pullMonitorCredentials = new Credentials(Guid.NewGuid(), "pull");
SetUpCredentialsProvider();
SetUpTimeCoordinator();
_endpoint = GetTestEndpoint();
}
public FastServer(string serverName, SessionProtocol sessionProtocol, Endpoint endpoint)
{
if (endpoint == null || sessionProtocol == null)
{
throw new System.NullReferenceException();
}
this.endpoint = endpoint;
this.sessionProtocol = sessionProtocol;
this.serverName = serverName;
endpoint.ConnectionListener = this;
}
public static Binding CreateBinding(Endpoint serviceInterface)
{
try
{
return BindingFactory.CreateBinding(serviceInterface);
}
catch (Exception ex)
{
throw new InvalidChannelBindingException(string.Format("Error creating binding {0}", serviceInterface.EndpointName),ex);
}
}
public EndpointInfo(Endpoint endpoint, string version)
{
if (endpoint == null)
{
throw new ArgumentNullException("endpoint", "endpoint is null.");
}
FullName = Name = endpoint.Name;
Version = version;
Host = endpoint.Host ?? String.Empty;
}
public static BytesReceivedEventArgs GetBytesReceivedResponse(Endpoint endpoint)
{
switch (endpoint)
{
case Endpoint.PutBytes:
return new BytesReceivedEventArgs(Util.CombineArrays(Util.GetBytes((ushort)1), Util.GetBytes((ushort)Endpoint.PutBytes), new byte[] { 1 }));
case Endpoint.SystemMessage:
return new BytesReceivedEventArgs(Util.CombineArrays(Util.GetBytes((ushort)2), Util.GetBytes((ushort)Endpoint.SystemMessage), new byte[] { 0, 0 }));
default:
throw new InvalidOperationException();
}
}
public void Configuration(IAppBuilder app)
{
InitializeLogging();
LogFactory.BuildLogger = type => new Log4NetLogger(type);
var config = WebApiConfig.Configure(app);
var endpoint = new Endpoint();
endpoint.Start();
config.DependencyResolver = ((WebApiAutofacAdapter)Settings.RootContainer).BuildAutofacDependencyResolver();
}
public static EndpointAddress EndpointAddress(string serviceName, Endpoint serviceInterface,string rootUrl)
{
try
{
var formater = Resolver.Activate<IEndpointUrlFormater>();
return formater.GetEndpointAddress(serviceName, serviceInterface, rootUrl);
}
catch (Exception ex)
{
throw new FormatException("Failure formating endpoint address",ex);
}
}
public Binding Create(Endpoint serviceInterface)
{
var binding = new NetTcpBinding(SecurityMode.None)
{
Name = serviceInterface.EndpointName,
HostNameComparisonMode = serviceInterface.HostNameComparisonMode.ParseAsEnum(HostNameComparisonMode.StrongWildcard),
MaxBufferPoolSize = serviceInterface.MaxBufferPoolSize,
MaxReceivedMessageSize = serviceInterface.MaxReceivedSize,
ReaderQuotas = XmlDictionaryReaderQuotas.Max,
TransferMode = TransferMode.Streamed
};
return binding;
}
/// <summary> Object.GetHashCode method override. </summary>
public override int GetHashCode()
{
// Note that Port cannot be used because Port==0 matches any non-zero Port value for .Equals
return(Endpoint.GetHashCode() ^ Generation.GetHashCode());
}
public JsonEndpoint(Endpoint endpoint)
{
serviceName = endpoint.Service_name;
ipv4 = new IPAddress(BitConverter.GetBytes(endpoint.Ipv4)).ToString();
port = endpoint.Port;
}
public void ProcessPrivacy(string usersFile, string privacyPreference)
{
List <string> usersList = new List <string>();
try
{
usersList = FileAccess.GetUsersFileData(usersFile);
}
catch (Exception ex)
{
Log.WriteLogEntry("ERROR", String.Format("Error while reading Users file: {0}", ex.Message), "Error while reading Users file.");
CleanupEnvironment();
Program.CloseApplicationOnError();
}
PrivacyModePreference userPrivacyPreference = PrivacyModePreference.None;
switch (privacyPreference.ToLowerInvariant())
{
case "default":
userPrivacyPreference = PrivacyModePreference.None;
break;
case "private":
userPrivacyPreference = PrivacyModePreference.Private;
break;
case "public":
userPrivacyPreference = PrivacyModePreference.Standard;
break;
default:
// Should not happen
Log.WriteLogEntry("ERROR", "Incorrect value for PrivacyPreference parameter.");
CleanupEnvironment();
Program.CloseApplicationOnError();
break;
}
if (usersList.Count > 0)
{
ucmaPlatform.StartupPlatform();
ucmaEndpoint = new Endpoint(ucmaPlatform.CollabPlatform);
PrivacyManager privacyManager = new PrivacyManager(ucmaEndpoint);
foreach (string user in usersList)
{
Log.WriteLogEntry("INFO", String.Format("Processing user {0}...", user.ToLowerInvariant()), String.Format("Processing user {0}...", user.ToLowerInvariant()));
try
{
privacyManager.SetPrivacyPreference(user, userPrivacyPreference);
}
catch (RegisterException rex)
{
Log.WriteLogEntry("ERROR", String.Format("Error while processing user {0}: {1}. Inner Exception: {2}. Diag Info: {3}.", user.ToLowerInvariant(), rex.Message, (rex.InnerException == null ? "N/A" : rex.InnerException.Message), (String.IsNullOrEmpty(rex.DiagnosticInformation.ToString()) ? "N/A" : rex.DiagnosticInformation.ToString())), String.Format("Error while processing user {0}", user.ToLowerInvariant()));
}
catch (Exception ex)
{
Log.WriteLogEntry("ERROR", String.Format("Error while processing user {0}: {1}. Inner Exception: {2}", user.ToLowerInvariant(), ex.Message, (ex.InnerException == null ? "N/A" : ex.InnerException.Message)), String.Format("Error while processing user {0}", user.ToLowerInvariant()));
}
}
}
else
{
Log.WriteLogEntry("WARNING", "Users file is empty or invalid. No action will be performed.");
}
}
public async Task Start()
{
var config = ConfigureEndpoint();
endpoint = await Endpoint.Start(config).ConfigureAwait(false);
}
internal Task <IList <StreamSubscriptionHandle <object> > > GetAllSubscriptionHandles()
{
return(Endpoint.GetAllSubscriptionHandles());
}
public void TestValidateNATNetworkPoliciesForManifestGenerationOnOpenForComposeScenario()
{
ApplicationTypeInformation applicationTypeInfo = new ApplicationTypeInformation("AppType", "1.0");
Application app = new Application();
app.name = "TestApp";
Management.ImageBuilder.SingleInstance.CodePackage cpkg = new Management.ImageBuilder.SingleInstance.CodePackage();
cpkg.image = "image";
cpkg.name = "CodePackage";
var endpoints = new List <Endpoint>();
var endpoint = new Endpoint();
endpoint.name = "publicListener";
endpoint.port = 8080;
endpoints.Add(endpoint);
cpkg.endpoints = endpoints;
var resource = new Resources();
var req = new ResourceDescription();
req.cpu = 0.5;
req.memoryInGB = 1;
resource.requests = req;
cpkg.resources = resource;
Service svc = new Service();
svc.properties.codePackages = new List <Management.ImageBuilder.SingleInstance.CodePackage>();
svc.properties.codePackages.Add(cpkg);
svc.name = "Svc1";
NetworkRef nref = new NetworkRef();
nref.name = StringConstants.NatNetworkName;
EndpointRef endpointRef = new EndpointRef();
endpointRef.name = "publicListener";
nref.endpointRefs = new List <EndpointRef>()
{
endpointRef
};
svc.properties.networkRefs = new List <NetworkRef>();
svc.properties.networkRefs.Add(nref);
app.properties.services = new List <Service>();
app.properties.services.Add(svc);
string applicationTestDir = Path.Combine(TestUtility.TestDirectory, Guid.NewGuid().ToString());
string currentExecutingDirectory = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
this.imageBuilder.BuildSingleInstanceApplication(app, "AppType", "1.0", "TestApp", new Uri("fabric:/TestApp"), false, TimeSpan.MaxValue, applicationTestDir, null, true, false, null, new GenerationConfig());
string expectedAppManifest = Path.Combine(applicationTestDir, "ApplicationManifest.xml");
var validatingXmlReaderSettings = new XmlReaderSettings();
validatingXmlReaderSettings.ValidationType = ValidationType.Schema;
validatingXmlReaderSettings.Schemas.Add(StringConstants.FabricNamespace, Path.Combine(currentExecutingDirectory, StringConstants.DefaultSchemaPath));
validatingXmlReaderSettings.XmlResolver = null;
var applicationManifestType = ImageBuilderUtility.ReadXml <ApplicationManifestType>(expectedAppManifest, validatingXmlReaderSettings);
ApplicationManifestTypeServiceManifestImport[] servicemanifestimports = applicationManifestType.ServiceManifestImport;
foreach (var serviceManifestImport in servicemanifestimports)
{
var policies = serviceManifestImport.Policies;
foreach (var policy in policies)
{
if (policy.GetType() == typeof(ContainerHostPoliciesType))
{
var ContainerHostPoliciesTypeItems = ((ContainerHostPoliciesType)policy).Items;
foreach (var item in ContainerHostPoliciesTypeItems)
{
if (item.GetType() == typeof(PortBindingType))
{
var portBindingType = (PortBindingType)item;
Verify.AreEqual("publicListener", portBindingType.EndpointRef);
Verify.AreEqual(8080, portBindingType.ContainerPort);
}
}
}
}
}
}
public void CreateNewPlan_For_State_Unit_SavesMemberDataCorrectly(
bool thisPeriodSubmitted,
bool lastPeriod1Submitted,
bool lastPeriod2Submitted
)
{
DateTimeDbTestExtensions.SetUtcNowToRandomDate();
var reportingTerms = ReportingPeriod.GetReportingTerms(reportingFrequency);
if (reportingTerms.All(o => o != reportingTerm))
{
return;
}
var testParams = Endpoint.ArrangeOnSqlSession(AssemblySetupFixture.EndpointTestContainer,
s =>
{
var organizations = IntegrationTestOrganizationHelper.SetupOrzanizations(
stateReportingFrequency: reportingFrequency,
zoneReportingFrequency: ReportingFrequency.Monthly);
var nswState = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.NswState).Value;
var laPerouse = new OrganizationBuilder()
.SetDescription("La perouse")
.SetOrganizationType(OrganizationType.Unit)
.SetReportingFreQuency(ReportingFrequency.Monthly)
.SetParent(nswState)
.BuildAndPersist(s);
var lalorPark = new OrganizationBuilder()
.SetDescription("Lalor park")
.SetOrganizationType(OrganizationType.Unit)
.SetReportingFreQuency(ReportingFrequency.Monthly)
.SetParent(nswState)
.BuildAndPersist(s);
var description = DataProvider.Get <string>();
var year = 2019;
OrganizationReference organizationRef = nswState;
var reportingPeriod = new ReportingPeriod(reportingFrequency, reportingTerm, year);
var expected = new StateReportBuilder()
.SetDescription(description)
.SetOrganization(organizationRef)
.SetReportingPeriod(new ReportingPeriod(reportingFrequency, reportingPeriod.ReportingTerm,
reportingPeriod.Year))
.Build();
var lastPeriod1 = reportingPeriod.GetReportingPeriodOfPreviousTerm();
var lastPeriod2 = lastPeriod1.GetReportingPeriodOfPreviousTerm();
var laPerouseThisPeriodUnitReport =
IntegrationTestStateReportHelper.BuildAndPersistUnitReport(thisPeriodSubmitted, laPerouse, reportingPeriod, s);
var laPerouseLastPeriod1UnitReport =
IntegrationTestStateReportHelper.BuildAndPersistUnitReport(lastPeriod1Submitted, laPerouse, lastPeriod1, s);
var laPerouseLastPeriod2UnitReport =
IntegrationTestStateReportHelper.BuildAndPersistUnitReport(lastPeriod2Submitted, laPerouse, lastPeriod2, s);
var lalorParkThisPeriodUnitReport =
IntegrationTestStateReportHelper.BuildAndPersistUnitReport(thisPeriodSubmitted, lalorPark, reportingPeriod, s);
var lalorParkLastPeriod1UnitReport =
IntegrationTestStateReportHelper.BuildAndPersistUnitReport(lastPeriod1Submitted, lalorPark, lastPeriod1, s);
var lalorParkLastPeriod2UnitReport =
IntegrationTestStateReportHelper.BuildAndPersistUnitReport(lastPeriod2Submitted, lalorPark, lastPeriod2, s);
var laPerouseUnitReports = new[]
{
laPerouseThisPeriodUnitReport,
laPerouseLastPeriod1UnitReport,
laPerouseLastPeriod2UnitReport,
};
var lalorParkeUnitReports = new[]
{
lalorParkThisPeriodUnitReport,
lalorParkLastPeriod1UnitReport,
lalorParkLastPeriod2UnitReport,
};
var lastSubmittedLapeRouseReport = IntegrationTestStateReportHelper.GetLastSubmittedReport(laPerouseUnitReports, reportingPeriod);
var lastSubmittedLalorParkReport = IntegrationTestStateReportHelper.GetLastSubmittedReport(lalorParkeUnitReports, reportingPeriod);
var submittedReports = new[] { lastSubmittedLapeRouseReport, lastSubmittedLalorParkReport }.Where(o => o != null).ToArray();
var expectedMemberMemberData = IntegrationTestStateReportHelper.GetExpectedMemberData(submittedReports, nameof(StateReport.MemberMemberData));
var expectedMemberMemberGeneratedData = expectedMemberMemberData;
var expectedAssociateMemberData = IntegrationTestStateReportHelper.GetExpectedMemberData(submittedReports, nameof(StateReport.AssociateMemberData));
var expectedAssociateMemberGeneratedData = expectedAssociateMemberData;
var expectedPreliminaryMemberData = IntegrationTestStateReportHelper.GetExpectedMemberData(submittedReports, nameof(StateReport.PreliminaryMemberData));
var expectedPreliminaryMemberGeneratedData = expectedPreliminaryMemberData;
var expectedSupporterMemberData = IntegrationTestStateReportHelper.GetExpectedMemberData(submittedReports, nameof(StateReport.SupporterMemberData));
var expectedSupporterMemberGeneratedData = expectedSupporterMemberData;
return(new
{
description,
reportingPeriod,
organizationRef,
expected,
expectedMemberMemberData,
expectedMemberMemberGeneratedData,
expectedAssociateMemberData,
expectedAssociateMemberGeneratedData,
expectedPreliminaryMemberData,
expectedPreliminaryMemberGeneratedData,
expectedSupporterMemberData,
expectedSupporterMemberGeneratedData,
});
});
var result = Endpoint.Act(AssemblySetupFixture.EndpointTestContainer,
c =>
{
var stateReport = c.GetInstance <IStateReportFactory>()
.CreateNewStatePlan(testParams.description,
testParams.organizationRef,
testParams.reportingPeriod.ReportingTerm,
testParams.reportingPeriod.Year,
reportingFrequency);
return(new
{
stateReport
});
});
result.stateReport.Should().NotBeNull();
//no need to repeat this section for the other field types
result.stateReport.Should().BeEquivalentTo(testParams.expected, e =>
e.Excluding(p => p.Id)
.Excluding(p => p.MemberMemberData)
.Excluding(p => p.MemberMemberGeneratedData)
.Excluding(p => p.AssociateMemberData)
.Excluding(p => p.AssociateMemberGeneratedData)
.Excluding(p => p.PreliminaryMemberData)
.Excluding(p => p.PreliminaryMemberGeneratedData)
.Excluding(p => p.SupporterMemberData)
.Excluding(p => p.SupporterMemberGeneratedData)
.Excluding(p => p.WorkerMeetingProgramData)
.Excluding(p => p.WorkerMeetingProgramGeneratedData)
.Excluding(p => p.DawahMeetingProgramData)
.Excluding(p => p.DawahMeetingProgramGeneratedData)
.Excluding(p => p.StateLeaderMeetingProgramData)
.Excluding(p => p.StateLeaderMeetingProgramGeneratedData)
.Excluding(p => p.StateOutingMeetingProgramData)
.Excluding(p => p.StateOutingMeetingProgramGeneratedData)
.Excluding(p => p.IftarMeetingProgramData)
.Excluding(p => p.IftarMeetingProgramGeneratedData)
.Excluding(p => p.LearningMeetingProgramData)
.Excluding(p => p.LearningMeetingProgramGeneratedData)
.Excluding(p => p.SocialDawahMeetingProgramData)
.Excluding(p => p.SocialDawahMeetingProgramGeneratedData)
.Excluding(p => p.DawahGroupMeetingProgramData)
.Excluding(p => p.DawahGroupMeetingProgramGeneratedData)
.Excluding(p => p.NextGMeetingProgramData)
.Excluding(p => p.NextGMeetingProgramGeneratedData)
.Excluding(p => p.CmsMeetingProgramData)
.Excluding(p => p.CmsMeetingProgramGeneratedData)
.Excluding(p => p.SmMeetingProgramData)
.Excluding(p => p.SmMeetingProgramGeneratedData)
.Excluding(p => p.MemberMeetingProgramData)
.Excluding(p => p.MemberMeetingProgramGeneratedData)
.Excluding(p => p.TafsirMeetingProgramData)
.Excluding(p => p.TafsirMeetingProgramGeneratedData)
.Excluding(p => p.UnitMeetingProgramData)
.Excluding(p => p.UnitMeetingProgramGeneratedData)
.Excluding(p => p.FamilyVisitMeetingProgramData)
.Excluding(p => p.FamilyVisitMeetingProgramGeneratedData)
.Excluding(p => p.EidReunionMeetingProgramData)
.Excluding(p => p.EidReunionMeetingProgramGeneratedData)
.Excluding(p => p.BbqMeetingProgramData)
.Excluding(p => p.BbqMeetingProgramGeneratedData)
.Excluding(p => p.GatheringMeetingProgramData)
.Excluding(p => p.GatheringMeetingProgramGeneratedData)
.Excluding(p => p.OtherMeetingProgramData)
.Excluding(p => p.OtherMeetingProgramGeneratedData)
.Excluding(p => p.GroupStudyTeachingLearningProgramData)
.Excluding(p => p.GroupStudyTeachingLearningProgramGeneratedData)
.Excluding(p => p.StudyCircleTeachingLearningProgramData)
.Excluding(p => p.StudyCircleTeachingLearningProgramGeneratedData)
.Excluding(p => p.PracticeDarsTeachingLearningProgramData)
.Excluding(p => p.PracticeDarsTeachingLearningProgramGeneratedData)
.Excluding(p => p.StateLearningCampTeachingLearningProgramData)
.Excluding(p => p.StateLearningCampTeachingLearningProgramGeneratedData)
.Excluding(p => p.QuranStudyTeachingLearningProgramData)
.Excluding(p => p.QuranStudyTeachingLearningProgramGeneratedData)
.Excluding(p => p.QuranClassTeachingLearningProgramData)
.Excluding(p => p.QuranClassTeachingLearningProgramGeneratedData)
.Excluding(p => p.MemorizingAyatTeachingLearningProgramData)
.Excluding(p => p.MemorizingAyatTeachingLearningProgramGeneratedData)
.Excluding(p => p.StateLearningSessionTeachingLearningProgramData)
.Excluding(p => p.StateLearningSessionTeachingLearningProgramGeneratedData)
.Excluding(p => p.StateQiyamulLailTeachingLearningProgramData)
.Excluding(p => p.StateQiyamulLailTeachingLearningProgramGeneratedData)
.Excluding(p => p.StudyCircleForAssociateMemberTeachingLearningProgramData)
.Excluding(p => p.StudyCircleForAssociateMemberTeachingLearningProgramGeneratedData)
.Excluding(p => p.HadithTeachingLearningProgramData)
.Excluding(p => p.HadithTeachingLearningProgramGeneratedData)
.Excluding(p => p.WeekendIslamicSchoolTeachingLearningProgramData)
.Excluding(p => p.WeekendIslamicSchoolTeachingLearningProgramGeneratedData)
.Excluding(p => p.MemorizingHadithTeachingLearningProgramData)
.Excluding(p => p.MemorizingHadithTeachingLearningProgramGeneratedData)
.Excluding(p => p.MemorizingDoaTeachingLearningProgramData)
.Excluding(p => p.MemorizingDoaTeachingLearningProgramGeneratedData)
.Excluding(p => p.OtherTeachingLearningProgramData)
.Excluding(p => p.OtherTeachingLearningProgramGeneratedData)
.Excluding(p => p.BookSaleMaterialData)
.Excluding(p => p.BookSaleMaterialGeneratedData)
.Excluding(p => p.BookDistributionMaterialData)
.Excluding(p => p.BookDistributionMaterialGeneratedData)
.Excluding(p => p.BookLibraryStockData)
.Excluding(p => p.BookLibraryStockGeneratedData)
.Excluding(p => p.OtherSaleMaterialData)
.Excluding(p => p.OtherSaleMaterialGeneratedData)
.Excluding(p => p.OtherDistributionMaterialData)
.Excluding(p => p.OtherDistributionMaterialGeneratedData)
.Excluding(p => p.OtherLibraryStockData)
.Excluding(p => p.OtherLibraryStockGeneratedData)
.Excluding(p => p.VhsSaleMaterialData)
.Excluding(p => p.VhsSaleMaterialGeneratedData)
.Excluding(p => p.VhsDistributionMaterialData)
.Excluding(p => p.VhsDistributionMaterialGeneratedData)
.Excluding(p => p.VhsLibraryStockData)
.Excluding(p => p.VhsLibraryStockGeneratedData)
.Excluding(p => p.EmailDistributionMaterialData)
.Excluding(p => p.EmailDistributionMaterialGeneratedData)
.Excluding(p => p.IpdcLeafletDistributionMaterialData)
.Excluding(p => p.IpdcLeafletDistributionMaterialGeneratedData)
.Excluding(p => p.BaitulMalFinanceData)
.Excluding(p => p.BaitulMalFinanceGeneratedData)
.Excluding(p => p.ADayMasjidProjectFinanceData)
.Excluding(p => p.ADayMasjidProjectFinanceGeneratedData)
.Excluding(p => p.MasjidTableBankFinanceData)
.Excluding(p => p.MasjidTableBankFinanceGeneratedData)
.Excluding(p => p.QardeHasanaSocialWelfareData)
.Excluding(p => p.QardeHasanaSocialWelfareGeneratedData)
.Excluding(p => p.PatientVisitSocialWelfareData)
.Excluding(p => p.PatientVisitSocialWelfareGeneratedData)
.Excluding(p => p.SocialVisitSocialWelfareData)
.Excluding(p => p.SocialVisitSocialWelfareGeneratedData)
.Excluding(p => p.TransportSocialWelfareData)
.Excluding(p => p.TransportSocialWelfareGeneratedData)
.Excluding(p => p.ShiftingSocialWelfareData)
.Excluding(p => p.ShiftingSocialWelfareGeneratedData)
.Excluding(p => p.ShoppingSocialWelfareData)
.Excluding(p => p.ShoppingSocialWelfareGeneratedData)
.Excluding(p => p.FoodDistributionSocialWelfareData)
.Excluding(p => p.FoodDistributionSocialWelfareGeneratedData)
.Excluding(p => p.CleanUpAustraliaSocialWelfareData)
.Excluding(p => p.CleanUpAustraliaSocialWelfareGeneratedData)
.Excluding(p => p.OtherSocialWelfareData)
.Excluding(p => p.OtherSocialWelfareGeneratedData)
);
result.stateReport.MemberMemberData.Should().BeEquivalentTo(testParams.expectedMemberMemberData);
result.stateReport.MemberMemberGeneratedData.Should().BeEquivalentTo(testParams.expectedMemberMemberGeneratedData);
result.stateReport.AssociateMemberData.Should().BeEquivalentTo(testParams.expectedAssociateMemberData);
result.stateReport.AssociateMemberGeneratedData.Should().BeEquivalentTo(testParams.expectedAssociateMemberGeneratedData);
result.stateReport.PreliminaryMemberData.Should().BeEquivalentTo(testParams.expectedPreliminaryMemberData);
result.stateReport.PreliminaryMemberGeneratedData.Should().BeEquivalentTo(testParams.expectedPreliminaryMemberGeneratedData);
result.stateReport.SupporterMemberData.Should().BeEquivalentTo(testParams.expectedSupporterMemberData);
result.stateReport.SupporterMemberGeneratedData.Should().BeEquivalentTo(testParams.expectedSupporterMemberGeneratedData);
}
private static void UpdateEndpoint(String regionId, String product, String domain, Endpoint endpoint)
{
ISet <String> regionIds = endpoint.RegionIds;
regionIds.Add(regionId);
List <ProductDomain> productDomains = endpoint.ProductDomains;
ProductDomain productDomain = FindProductDomain(productDomains, product);
if (null == productDomain)
{
productDomains.Add(new ProductDomain(product, domain));
}
else
{
productDomain.DomianName = domain;
}
}
public EndpointDependTestClass1(Endpoint endpoint1)
{
Endpoint = endpoint1;
}
void OnShutdown()
{
Endpoint?.Stop().GetAwaiter().GetResult();
}
public static void ParseFileLines(string[] fileLines,
out Video[] videos,
out Endpoint[] endpoints,
out CacheServer[] cacheServers,
out RequestDescription[] requests,
IProgress <float> progress
)
{
progress.Report(0);
int totalLines = fileLines.Length;
int currentLine = 0;
int[] specs = fileLines[currentLine].Split(' ').Select(int.Parse).ToArray();
progress.Report(currentLine / (float)totalLines);
int videoCount = specs[0];
int endpointCount = specs[1];
int requestCount = specs[2];
int cachServerCount = specs[3];
int cachecapacity = specs[4];
// init Arrays
cacheServers = new CacheServer[cachServerCount];
videos = new Video[videoCount];
endpoints = new Endpoint[endpointCount];
requests = new RequestDescription[requestCount];
CacheServer.MAXSIZE = cachecapacity;
for (int i = 0; i < cachServerCount; i++)
{
cacheServers[i] = new CacheServer(i);
}
// Parse Videos
int[] videoSizes = fileLines[++currentLine].Split(' ').Select(int.Parse).ToArray();
if (videoSizes.Length != videoCount)
{
throw new Exception("Video Count mismatch");
}
for (int i = 0; i < videoSizes.Length; i++)
{
var newVideo = new Video(videoSizes[i], i);
videos[i] = newVideo;
}
// ParseEndpoints and cacheData
for (int i = 0; i < endpointCount; i++)
{
progress.Report(currentLine / (float)totalLines);
int endpointId = ++currentLine;
int[] endpointSpecs = fileLines[endpointId].Split(' ').Select(int.Parse).ToArray();
int endpointLatency = endpointSpecs[0];
int connectedCaches = endpointSpecs[1];
var newEndpoint = new Endpoint(endpointId, endpointLatency);
for (int j = 0; j < connectedCaches; j++)
{
int[] cacheSpecs = fileLines[++currentLine].Split(' ').Select(int.Parse).ToArray();
int cacheId = cacheSpecs[0];
int cacheLatency = cacheSpecs[1];
// Add cache Server Info
newEndpoint.AddCacheConnection(cacheServers[cacheId], cacheLatency);
}
endpoints[i] = newEndpoint;
}
// Parse Requests
for (int i = 0; i < requestCount; i++)
{
progress.Report(currentLine / (float)totalLines);
int[] requestSpecs = fileLines[++currentLine].Split(' ').Select(int.Parse).ToArray();
int videoId = requestSpecs[0];
int endpointId = requestSpecs[1];
int numberOfRequests = requestSpecs[2];
var newRequest = new RequestDescription(videos[videoId], endpoints[endpointId], numberOfRequests);
requests[i] = newRequest;
}
progress.Report(1);
}
public EndpointDependTestClass2(Endpoint endpoint1, Endpoint endpoint2)
{
Endpoint1 = endpoint1;
Endpoint2 = endpoint2;
}
public void CustomDomainCRUDTest()
{
var handler1 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
var handler2 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (MockContext context = MockContext.Start(this.GetType()))
{
// Create clients
var cdnMgmtClient = CdnTestUtilities.GetCdnManagementClient(context, handler1);
var resourcesClient = CdnTestUtilities.GetResourceManagementClient(context, handler2);
// Create resource group
var resourceGroupName = CdnTestUtilities.CreateResourceGroup(resourcesClient);
// Create a standard cdn profile
string profileName = TestUtilities.GenerateName("profile");
Profile createParameters = new Profile
{
Location = "WestUs",
Sku = new Sku {
Name = SkuName.StandardMicrosoft
},
Tags = new Dictionary <string, string>
{
{ "key1", "value1" },
{ "key2", "value2" }
}
};
var profile = cdnMgmtClient.Profiles.Create(resourceGroupName, profileName, createParameters);
// Create a cdn endpoint with minimum requirements
string endpointName = "endpoint-f3757d2a3e10";
var endpointCreateParameters = new Endpoint
{
Location = "WestUs",
IsHttpAllowed = true,
IsHttpsAllowed = true,
Origins = new List <DeepCreatedOrigin>
{
new DeepCreatedOrigin
{
Name = "origin1",
HostName = "host1.hello.com"
}
}
};
var endpoint = cdnMgmtClient.Endpoints.Create(resourceGroupName, profileName, endpointName, endpointCreateParameters);
// List custom domains one this endpoint should return none
var customDomains = cdnMgmtClient.CustomDomains.ListByEndpoint(resourceGroupName, profileName, endpointName);
Assert.Empty(customDomains);
// NOTE: There is a CName mapping already created for this custom domain and endpoint hostname
// "sdk-1-f3757d2a3e10.DUSTYDOGPETCARE.US" maps to "endpoint-f3757d2a3e10.azureedge.net"
// "sdk-2-f3757d2a3e10.DUSTYDOGPETCARE.US" maps to "endpoint-f3757d2a3e10.azureedge.net"
// Create custom domain on running endpoint should succeed
string customDomainName1 = TestUtilities.GenerateName("customDomain");
cdnMgmtClient.CustomDomains.Create(resourceGroupName, profileName, endpointName, customDomainName1, "sdk-1-f3757d2a3e10.DUSTYDOGPETCARE.US");
// List custom domains one this endpoint should return one
customDomains = cdnMgmtClient.CustomDomains.ListByEndpoint(resourceGroupName, profileName, endpointName);
Assert.Single(customDomains);
// Stop endpoint
cdnMgmtClient.Endpoints.Stop(resourceGroupName, profileName, endpointName);
// Create another custom domain on stopped endpoint should succeed
string customDomainName2 = TestUtilities.GenerateName("customDomain");
cdnMgmtClient.CustomDomains.Create(resourceGroupName, profileName, endpointName, customDomainName2, "sdk-2-f3757d2a3e10.DUSTYDOGPETCARE.US");
// List custom domains one this endpoint should return two
customDomains = cdnMgmtClient.CustomDomains.ListByEndpoint(resourceGroupName, profileName, endpointName);
Assert.Equal(2, customDomains.Count());
// Disable custom https on custom domain that is not enabled should fail
Assert.ThrowsAny <ErrorResponseException>(() =>
{
cdnMgmtClient.CustomDomains.DisableCustomHttps(resourceGroupName, profileName, endpointName, customDomainName2);
});
// Delete second custom domain on stopped endpoint should succeed
cdnMgmtClient.CustomDomains.Delete(resourceGroupName, profileName, endpointName, customDomainName2);
// Get deleted custom domain should fail
Assert.ThrowsAny <ErrorResponseException>(() =>
{
cdnMgmtClient.CustomDomains.Get(resourceGroupName, profileName, endpointName, customDomainName2);
});
// List custom domains on endpoint should return one
customDomains = cdnMgmtClient.CustomDomains.ListByEndpoint(resourceGroupName, profileName, endpointName);
Assert.Single(customDomains);
// Start endpoint
cdnMgmtClient.Endpoints.Start(resourceGroupName, profileName, endpointName);
// Enable custom https using CDN managed certificate on custom domain
cdnMgmtClient.CustomDomains.EnableCustomHttps(resourceGroupName, profileName, endpointName, customDomainName1);
// add the same deleted custom domain again
cdnMgmtClient.CustomDomains.Create(resourceGroupName, profileName, endpointName, customDomainName2, "sdk-2-f3757d2a3e10.DUSTYDOGPETCARE.US");
// Enable custom https using BYOC on custom domain
var byocParameters = new KeyVaultCertificateSourceParameters()
{
ResourceGroupName = "byoc",
SecretName = "CdnSDKE2EBYOCTest",
SecretVersion = "526c5d25cc1a46a5bb85ce85ee2b89cc",
SubscriptionId = "3c0124f9-e564-4c42-86f7-fa79457aedc3",
VaultName = "Azure-CDN-BYOC"
};
cdnMgmtClient.CustomDomains.EnableCustomHttps(resourceGroupName, profileName, endpointName, customDomainName2, new UserManagedHttpsParameters(ProtocolType.ServerNameIndication, byocParameters));
// Delete first custom domain should succeed
cdnMgmtClient.CustomDomains.Delete(resourceGroupName, profileName, endpointName, customDomainName1);
// Get deleted custom domain should fail
Assert.ThrowsAny <ErrorResponseException>(() =>
{
cdnMgmtClient.CustomDomains.Get(resourceGroupName, profileName, endpointName, customDomainName1);
});
// Delete second custom domain should succeed
cdnMgmtClient.CustomDomains.Delete(resourceGroupName, profileName, endpointName, customDomainName2);
// Get deleted custom domain should fail
Assert.ThrowsAny <ErrorResponseException>(() =>
{
cdnMgmtClient.CustomDomains.Get(resourceGroupName, profileName, endpointName, customDomainName2);
});
// List custom domains on endpoint should return none
customDomains = cdnMgmtClient.CustomDomains.ListByEndpoint(resourceGroupName, profileName, endpointName);
Assert.Empty(customDomains);
// Delete resource group
CdnTestUtilities.DeleteResourceGroup(resourcesClient, resourceGroupName);
}
}
public MessageLoggingModule(IEndpointRouter endpointRouter, Uri logQueue)
{
logEndpoint = endpointRouter.GetRoutedEndpoint(logQueue);
}
public virtual Task Push(object item)
{
return(Endpoint.OnNextAsync(item));
}
public AuditEndpointExplorerItem(Endpoint endpoint)
: base(endpoint)
{
}
static async Task MainAsync()
{
Console.Title = "Samples.ASB.Polymorphic.Subscriber";
var endpointConfiguration = new EndpointConfiguration("Samples.ASB.Polymorphic.Subscriber");
var transport = endpointConfiguration.UseTransport <AzureServiceBusTransport>();
var connectionString = Environment.GetEnvironmentVariable("AzureServiceBus.ConnectionString");
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new Exception("Could not read the 'AzureServiceBus.ConnectionString' environment variable. Check the sample prerequisites.");
}
transport.ConnectionString(connectionString);
var topology = transport.UseTopology <EndpointOrientedTopology>();
transport.Sanitization().UseStrategy <ValidateAndHashIfNeeded>();
#region RegisterPublisherNames
topology.RegisterPublisher(typeof(BaseEvent), "Samples.ASB.Polymorphic.Publisher");
topology.RegisterPublisher(typeof(DerivedEvent), "Samples.ASB.Polymorphic.Publisher");
#endregion
endpointConfiguration.SendFailedMessagesTo("error");
#region DisableAutoSubscripton
endpointConfiguration.DisableFeature <AutoSubscribe>();
#endregion
endpointConfiguration.UseSerialization <JsonSerializer>();
endpointConfiguration.EnableInstallers();
endpointConfiguration.UsePersistence <InMemoryPersistence>();
var recoverability = endpointConfiguration.Recoverability();
recoverability.Delayed(
customizations: settings =>
{
settings.NumberOfRetries(0);
});
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
try
{
#region ControledSubscriptions
await endpointInstance.Subscribe <BaseEvent>()
.ConfigureAwait(false);
#endregion
Console.WriteLine("Subscriber is ready to receive events");
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpointInstance.Stop()
.ConfigureAwait(false);
}
}
public void ProcessContacts(string usersFile, string contactsFile, string contactsGroup, bool deletionMode)
{
List <string> usersList = new List <string>();
List <ContactItem> contactsList = new List <ContactItem>();
try
{
usersList = FileAccess.GetUsersFileData(usersFile);
}
catch (Exception ex)
{
Log.WriteLogEntry("ERROR", String.Format("Error while reading Users file: {0}", ex.Message), "Error while reading Users file.");
CleanupEnvironment();
Program.CloseApplicationOnError();
}
try
{
contactsList = FileAccess.GetContactsFileData(contactsFile);
}
catch (Exception ex)
{
Log.WriteLogEntry("ERROR", String.Format("Error while reading Contacts file: {0}", ex.Message), "Error while reading Contacts file.");
CleanupEnvironment();
Program.CloseApplicationOnError();
}
if ((contactsList.Count > 0) && (usersList.Count > 0))
{
ucmaPlatform.StartupPlatform();
ucmaEndpoint = new Endpoint(ucmaPlatform.CollabPlatform);
ContactListManager contactListManager = new ContactListManager(ucmaEndpoint);
foreach (string user in usersList)
{
Log.WriteLogEntry("INFO", String.Format("Processing user {0}...", user.ToLowerInvariant()), String.Format("Processing user {0}...", user.ToLowerInvariant()));
try
{
if (!deletionMode)
{
contactListManager.AddContacts(user, contactsList, contactsGroup);
}
else
{
contactListManager.RemoveContacts(user, contactsList);
}
}
catch (RegisterException rex)
{
Log.WriteLogEntry("ERROR", String.Format("Error while processing user {0}: {1}. Inner Exception: {2}. Diag Info: {3}.", user.ToLowerInvariant(), rex.Message, (rex.InnerException == null ? "N/A" : rex.InnerException.Message), (String.IsNullOrEmpty(rex.DiagnosticInformation.ToString()) ? "N/A" : rex.DiagnosticInformation.ToString())), String.Format("Error while processing user {0}", user.ToLowerInvariant()));
}
catch (PublishSubscribeException pex)
{
// If contact list provide is UCS (Exchange Server 2013)
if (pex.DiagnosticInformation.ErrorCode == 2164)
{
Log.WriteLogEntry("WARNING", String.Format("Error while processing user {0}: User's contact list is stored in Unified Contact Store. It can't be managed by {1}", user.ToLowerInvariant(), LumtGlobals.ApplicationShortName), String.Format("Error while processing user {0}", user.ToLowerInvariant()));
}
else
{
Log.WriteLogEntry("ERROR", String.Format("Error while processing user {0}: {1}. Inner Exception: {2}. Diag Info: {3}.", user.ToLowerInvariant(), pex.Message, (pex.InnerException == null ? "N/A" : pex.InnerException.Message), (String.IsNullOrEmpty(pex.DiagnosticInformation.ToString()) ? "N/A" : pex.DiagnosticInformation.ToString())), String.Format("Error while processing user {0}", user.ToLowerInvariant()));
}
}
catch (Exception ex)
{
Log.WriteLogEntry("ERROR", String.Format("Error while processing user {0}: {1}. Inner Exception: {2}", user.ToLowerInvariant(), ex.Message, (ex.InnerException == null ? "N/A" : ex.InnerException.Message)), String.Format("Error while processing user {0}", user.ToLowerInvariant()));
}
}
}
else
{
Log.WriteLogEntry("WARNING", "Users or Contacts file is empty or invalid. No action will be performed.");
}
}
static async Task Main()
{
var endpointConfiguration = new EndpointConfiguration("SmokeTest.ClientNoHeartbeat");
endpointConfiguration.UseTransport <LearningTransport>();
var enpointInstance = await Endpoint.Start(endpointConfiguration);
Console.WriteLine("Press enter to send a message");
Console.WriteLine("Press any key to exit");
var exit = false;
do
{
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("-------------------------------------");
Console.WriteLine("[ A ] Send 1 good Message");
Console.WriteLine("[ B ] Send 10 bad Messages");
Console.WriteLine("[ C ] Send Infinite bad Messages ");
Console.WriteLine("[ Q ] Quit");
Console.WriteLine("-------------------------------------");
Console.Write("Make a Choice: ");
var key = Console.ReadKey();
Console.WriteLine();
string text = wordblob.LoremIpsum(5, 5, 1, 1, 1);
#pragma warning disable IDE0010 // Add missing cases
switch (key.Key)
#pragma warning restore IDE0010 // Add missing cases
{
case ConsoleKey.A:
await SendMessage(enpointInstance, false, text);
break;
case ConsoleKey.B:
for (var i = 0; i < 10; i++)
{
await SendMessage(enpointInstance, true, text);
}
break;
case ConsoleKey.C:
while (!Console.KeyAvailable)
{
await SendMessage(enpointInstance, true, text);
Task.Delay(200).Wait(); // 5 messages a second
Console.WriteLine("Press any key to stop sending messages");
}
break;
case ConsoleKey.Q:
exit = true;
break;
default:
Console.WriteLine("Option not valid, Try again.");
continue;
}
}while (!exit);
await enpointInstance.Stop();
}
public ProductsCall(Endpoint endpoint, Payload payload) : base(endpoint, payload)
{
}
public IndexedEndpoint(int index, Endpoint endpoint)
{
Index = index;
Endpoint = endpoint;
}
static (IReadOnlyList <string> httpMethods, bool acceptCorsPreflight) GetHttpMethods(Endpoint e)
{
var metadata = e.Metadata.GetMetadata <IHttpMethodMetadata>();
return(metadata == null ? (Array.Empty <string>(), false) : (metadata.HttpMethods, metadata.AcceptCorsPreflight));
}
static async Task AsyncMain()
{
Console.Title = "Samples.MultiTenant.Receiver";
var sharedDatabaseConfiguration = CreateBasicNHibernateConfig();
var tenantDatabasesConfiguration = CreateBasicNHibernateConfig();
var mapper = new ModelMapper();
mapper.AddMapping <OrderMap>();
tenantDatabasesConfiguration.AddMapping(mapper.CompileMappingForAllExplicitlyAddedEntities());
var endpointConfiguration = new EndpointConfiguration("Samples.MultiTenant.Receiver");
endpointConfiguration.UseSerialization <JsonSerializer>();
endpointConfiguration.LimitMessageProcessingConcurrencyTo(1);
endpointConfiguration.SendFailedMessagesTo("error");
#region ReceiverConfiguration
var persistence = endpointConfiguration.UsePersistence <NHibernatePersistence>();
persistence.UseConfiguration(tenantDatabasesConfiguration);
persistence.UseSubscriptionStorageConfiguration(sharedDatabaseConfiguration);
persistence.UseTimeoutStorageConfiguration(sharedDatabaseConfiguration);
persistence.DisableSchemaUpdate();
endpointConfiguration.EnableOutbox();
var settingsHolder = endpointConfiguration.GetSettings();
settingsHolder.Set("NHibernate.Timeouts.AutoUpdateSchema", true);
settingsHolder.Set("NHibernate.Subscriptions.AutoUpdateSchema", true);
#endregion
#region ReplaceOpenSqlConnection
endpointConfiguration.Pipeline.Register <ExtractTenantConnectionStringBehavior.Registration>();
#endregion
#region RegisterPropagateTenantIdBehavior
endpointConfiguration.Pipeline.Register <PropagateOutgoingTenantIdBehavior.Registration>();
endpointConfiguration.Pipeline.Register <PropagateIncomingTenantIdBehavior.Registration>();
#endregion
var startableEndpoint = await Endpoint.Create(endpointConfiguration)
.ConfigureAwait(false);
#region CreateSchema
CreateSchema(tenantDatabasesConfiguration, "A");
CreateSchema(tenantDatabasesConfiguration, "B");
#endregion
var endpointInstance = await startableEndpoint.Start()
.ConfigureAwait(false);
Console.WriteLine("Press any key to exit");
Console.ReadKey();
if (endpointInstance != null)
{
await endpointInstance.Stop()
.ConfigureAwait(false);
}
}
/// <summary>
/// VoIP endpoint. Must only create one endpoint for multiple accounts.
/// </summary>
/// <param name="useIPv6">Use IPv6.</param>
/// <param name="transportType">The transport type flags.</param>
public VoIPEndpoint(Nequeo.Net.PjSip.IPv6_Use useIPv6, Nequeo.Net.PjSip.TransportType transportType)
{
_endpoint = new Endpoint();
_endpoint.Initialise(useIPv6, transportType);
}
public UdpListener(Endpoint endpoint)
{
this.parent = endpoint;
this.log = endpoint.Logger;
}
public virtual HttpResponse DoAction <T>(AcsRequest <T> request, bool autoRetry, int maxRetryNumber, string regionId,
AlibabaCloudCredentials credentials, Signer signer, FormatType?format, List <Endpoint> endpoints) where T : AcsResponse
{
FormatType?requestFormatType = request.AcceptFormat;
if (null != requestFormatType)
{
format = requestFormatType;
}
ProductDomain domain = null;
if (request.ProductDomain != null)
{
domain = request.ProductDomain;
}
else
{
domain = Endpoint.FindProductDomain(regionId, request.Product, endpoints);
}
if (null == domain)
{
throw new ClientException("SDK.InvalidRegionId", "Can not find endpoint to access.");
}
request.Headers["User-Agent"] = UserAgent.Resolve(request.GetSysUserAgentConfig(), this.userAgentConfig);
bool shouldRetry = true;
for (int retryTimes = 0; shouldRetry; retryTimes++)
{
shouldRetry = autoRetry && retryTimes < maxRetryNumber;
HttpRequest httpRequest = request.SignRequest(signer, credentials, format, domain);
ResolveTimeout(httpRequest);
SetHttpsInsecure(IgnoreCertificate);
ResolveProxy(httpRequest, request);
HttpResponse response = this.GetResponse(httpRequest);
PrintHttpDebugMsg(request, response);
if (response.Content == null)
{
if (shouldRetry)
{
continue;
}
else
{
throw new ClientException("SDK.ConnectionReset", "Connection reset.");
}
}
if (500 <= response.Status && shouldRetry)
{
continue;
}
return(response);
}
return(null);
}
public void ProcessAlertNotifications(string usersFile, string alertWhenAddToContactListNotification, string alertWhenDNDNotification)
{
List <string> usersList = new List <string>();
try
{
usersList = FileAccess.GetUsersFileData(usersFile);
}
catch (Exception ex)
{
Log.WriteLogEntry("ERROR", String.Format("Error while reading Users file: {0}", ex.Message), "Error while reading Users file.");
CleanupEnvironment();
Program.CloseApplicationOnError();
}
NotifyAdditionToContactListType notifyAdditionToContactList = NotifyAdditionToContactListType.NoChange;
switch (alertWhenAddToContactListNotification.ToLowerInvariant())
{
case "":
notifyAdditionToContactList = NotifyAdditionToContactListType.NoChange;
break;
case "yes":
notifyAdditionToContactList = NotifyAdditionToContactListType.Yes;
break;
case "no":
notifyAdditionToContactList = NotifyAdditionToContactListType.No;
break;
default:
// Should not happen
Log.WriteLogEntry("ERROR", "Incorrect value for NotifyAdd parameter.");
CleanupEnvironment();
Program.CloseApplicationOnError();
break;
}
AlertsWhenDoNotDisturbType alertsWhenDoNotDisturb = AlertsWhenDoNotDisturbType.NoChange;
switch (alertWhenDNDNotification.ToLowerInvariant())
{
case "":
alertsWhenDoNotDisturb = AlertsWhenDoNotDisturbType.NoChange;
break;
case "noalerts":
alertsWhenDoNotDisturb = AlertsWhenDoNotDisturbType.NoAlerts;
break;
case "allalerts":
alertsWhenDoNotDisturb = AlertsWhenDoNotDisturbType.DisplayAllAlerts;
break;
case "alertsfromworkgroup":
alertsWhenDoNotDisturb = AlertsWhenDoNotDisturbType.DisplayAlertsFromHighPresence;
break;
default:
// Should not happen
Log.WriteLogEntry("ERROR", "Incorrect value for NotifyWhenDND parameter.");
CleanupEnvironment();
Program.CloseApplicationOnError();
break;
}
if (usersList.Count > 0)
{
ucmaPlatform.StartupPlatform();
ucmaEndpoint = new Endpoint(ucmaPlatform.CollabPlatform);
AlertsManager alertsManager = new AlertsManager(ucmaEndpoint);
foreach (string user in usersList)
{
Log.WriteLogEntry("INFO", String.Format("Processing user {0}...", user.ToLowerInvariant()), String.Format("Processing user {0}...", user.ToLowerInvariant()));
try
{
alertsManager.SetAlertNotificationSetting(user, notifyAdditionToContactList, alertsWhenDoNotDisturb);
}
catch (RegisterException rex)
{
Log.WriteLogEntry("ERROR", String.Format("Error while processing user {0}: {1}. Inner Exception: {2}. Diag Info: {3}.", user.ToLowerInvariant(), rex.Message, (rex.InnerException == null ? "N/A" : rex.InnerException.Message), (String.IsNullOrEmpty(rex.DiagnosticInformation.ToString()) ? "N/A" : rex.DiagnosticInformation.ToString())), String.Format("Error while processing user {0}", user.ToLowerInvariant()));
}
catch (Exception ex)
{
Log.WriteLogEntry("ERROR", String.Format("Error while processing user {0}: {1}. Inner Exception: {2}", user.ToLowerInvariant(), ex.Message, (ex.InnerException == null ? "N/A" : ex.InnerException.Message)), String.Format("Error while processing user {0}", user.ToLowerInvariant()));
}
}
}
else
{
Log.WriteLogEntry("WARNING", "Users file is empty or invalid. No action will be performed.");
}
}
public void Initialize(Endpoint source)
{
endpoint = source;
}
/// <summary>
/// Takes the configuration class and converts it to a SAML2.0 metadata document.
/// </summary>
/// <param name="config">The config.</param>
/// <param name="keyInfo">The keyInfo.</param>
private void ConvertToMetadata(Saml2Config config, KeyInfo keyInfo)
{
var entity = CreateDefaultEntity();
entity.EntityID = config.ServiceProvider.Id;
entity.ValidUntil = DateTime.Now + config.Metadata.Lifetime;
var serviceProviderDescriptor = new SpSsoDescriptor
{
ProtocolSupportEnumeration = new[] { Saml20Constants.Protocol },
AuthnRequestsSigned = XmlConvert.ToString(true),
WantAssertionsSigned = XmlConvert.ToString(true)
};
if (config.ServiceProvider.NameIdFormats.Count > 0)
{
serviceProviderDescriptor.NameIdFormat = new string[config.ServiceProvider.NameIdFormats.Count];
var count = 0;
foreach (var nameIdFormat in config.ServiceProvider.NameIdFormats)
{
serviceProviderDescriptor.NameIdFormat[count++] = nameIdFormat;
}
}
var baseUrl = new Uri(config.ServiceProvider.Server);
var logoutServiceEndpoints = new List <Endpoint>();
var signonServiceEndpoints = new List <IndexedEndpoint>();
var artifactResolutionEndpoints = new List <IndexedEndpoint>(2);
// Include endpoints.
foreach (var endpoint in config.ServiceProvider.Endpoints)
{
if (endpoint.Type == EndpointType.SignOn)
{
var loginEndpoint = new IndexedEndpoint
{
Index = endpoint.Index,
IsDefault = true,
Location = new Uri(baseUrl, endpoint.LocalPath).ToString(),
Binding = GetBinding(endpoint.Binding, Saml20Constants.ProtocolBindings.HttpPost)
};
signonServiceEndpoints.Add(loginEndpoint);
var artifactSignonEndpoint = new IndexedEndpoint
{
Binding = Saml20Constants.ProtocolBindings.HttpSoap,
Index = loginEndpoint.Index,
Location = loginEndpoint.Location
};
artifactResolutionEndpoints.Add(artifactSignonEndpoint);
}
else if (endpoint.Type == EndpointType.Logout)
{
var logoutEndpoint = new Endpoint
{
Location = new Uri(baseUrl, endpoint.LocalPath).ToString()
};
logoutEndpoint.ResponseLocation = logoutEndpoint.Location;
logoutEndpoint.Binding = GetBinding(endpoint.Binding, Saml20Constants.ProtocolBindings.HttpPost);
logoutServiceEndpoints.Add(logoutEndpoint);
var artifactLogoutEndpoint = new IndexedEndpoint
{
Binding = Saml20Constants.ProtocolBindings.HttpSoap,
Index = endpoint.Index,
Location = logoutEndpoint.Location
};
artifactResolutionEndpoints.Add(artifactLogoutEndpoint);
}
}
serviceProviderDescriptor.SingleLogoutService = logoutServiceEndpoints.ToArray();
serviceProviderDescriptor.AssertionConsumerService = signonServiceEndpoints.ToArray();
// Attribute consuming service.
if (config.Metadata.RequestedAttributes.Count > 0)
{
var attConsumingService = new AttributeConsumingService();
serviceProviderDescriptor.AttributeConsumingService = new[] { attConsumingService };
attConsumingService.Index = signonServiceEndpoints[0].Index;
attConsumingService.IsDefault = true;
attConsumingService.ServiceName = new[] { new LocalizedName("SP", "en") };
attConsumingService.RequestedAttribute = new RequestedAttribute[config.Metadata.RequestedAttributes.Count];
for (var i = 0; i < config.Metadata.RequestedAttributes.Count; i++)
{
attConsumingService.RequestedAttribute[i] = new RequestedAttribute
{
Name = config.Metadata.RequestedAttributes[i].Name,
NameFormat = SamlAttribute.NameformatBasic,
IsRequired = config.Metadata.RequestedAttributes[i].IsRequired
};
}
}
else
{
serviceProviderDescriptor.AttributeConsumingService = new AttributeConsumingService[0];
}
if (!config.Metadata.ExcludeArtifactEndpoints)
{
serviceProviderDescriptor.ArtifactResolutionService = artifactResolutionEndpoints.ToArray();
}
entity.Items = new object[] { serviceProviderDescriptor };
// Keyinfo
var keySigning = new KeyDescriptor();
var keyEncryption = new KeyDescriptor();
serviceProviderDescriptor.KeyDescriptor = new[] { keySigning, keyEncryption };
keySigning.Use = KeyTypes.Signing;
keySigning.UseSpecified = true;
keyEncryption.Use = KeyTypes.Encryption;
keyEncryption.UseSpecified = true;
// Ugly conversion between the .Net framework classes and our classes ... avert your eyes!!
keySigning.KeyInfo = Serialization.DeserializeFromXmlString <Schema.XmlDSig.KeyInfo>(keyInfo.GetXml().OuterXml);
keyEncryption.KeyInfo = keySigning.KeyInfo;
// apply the <Organization> element
if (config.Metadata.Organization != null)
{
entity.Organization = new Schema.Metadata.Organization
{
OrganizationName = new[] { new LocalizedName {
Value = config.Metadata.Organization.Name
} },
OrganizationDisplayName = new[] { new LocalizedName {
Value = config.Metadata.Organization.DisplayName
} },
OrganizationURL = new[] { new LocalizedURI {
Value = config.Metadata.Organization.Url
} }
};
}
if (config.Metadata.Contacts.Count > 0)
{
entity.ContactPerson = config.Metadata.Contacts.Select(x => new Schema.Metadata.Contact
{
ContactType =
(Schema.Metadata.ContactType)
((int)x.Type),
Company = x.Company,
GivenName = x.GivenName,
SurName = x.SurName,
EmailAddress = new[] { x.Email },
TelephoneNumber = new[] { x.Phone }
}).ToArray();
}
}
static async Task Main()
{
Console.Title = "Samples.SqlOutbox.Sender";
var random = new Random();
var endpointConfiguration = new EndpointConfiguration("Samples.SqlOutbox.Sender");
endpointConfiguration.EnableInstallers();
endpointConfiguration.SendFailedMessagesTo("error");
#region SenderConfiguration
var connection = @"Data Source=.\SqlExpress;Database=NsbSamplesSqlOutbox;Integrated Security=True;Max Pool Size=100";
var transport = endpointConfiguration.UseTransport <SqlServerTransport>();
transport.ConnectionString(connection);
transport.DefaultSchema("sender");
transport.UseSchemaForQueue("error", "dbo");
transport.UseSchemaForQueue("audit", "dbo");
var persistence = endpointConfiguration.UsePersistence <SqlPersistence>();
persistence.ConnectionBuilder(
connectionBuilder: () =>
{
return(new SqlConnection(connection));
});
var dialect = persistence.SqlDialect <SqlDialect.MsSqlServer>();
dialect.Schema("sender");
persistence.TablePrefix("");
var subscriptions = persistence.SubscriptionSettings();
subscriptions.DisableCache();
endpointConfiguration.EnableOutbox();
#endregion
SqlHelper.CreateSchema(connection, "sender");
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
Console.WriteLine("Press enter to send a message");
Console.WriteLine("Press any key to exit");
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
if (key.Key != ConsoleKey.Enter)
{
break;
}
var orderSubmitted = new OrderSubmitted
{
OrderId = Guid.NewGuid(),
Value = random.Next(100)
};
await endpointInstance.Publish(orderSubmitted)
.ConfigureAwait(false);
}
await endpointInstance.Stop()
.ConfigureAwait(false);
}
