public AccountController(
UserManager userManager,
IEventService events,
IIdentityServerInteractionService interaction,
IdentitySignInManager signInManager,
IdentityUserManager identityUserManager,
MessageSenderManager messageSenderManager,
ReturnUrlConfiguration returnUrlConfiguration,
ILocalizationService localization,
NonceManager nonceManager,
DynamicModuleProvider dynamicModuleProvider,
FeatureFlagsManager featureFlagsManager
)
{
m_userManager = userManager;
m_events = events;
m_interaction = interaction;
m_signInManager = signInManager;
m_identityUserManager = identityUserManager;
m_messageSenderManager = messageSenderManager;
m_returnUrlConfiguration = returnUrlConfiguration;
m_localization = localization;
m_nonceManager = nonceManager;
m_dynamicModuleProvider = dynamicModuleProvider;
m_featureFlagsManager = featureFlagsManager;
}
internal static SecuritySystem StartTheSystem(ISecurityDataProvider securityDataProvider)
{
var messageSenderManager = new MessageSenderManager("asdf");
// Call SecurityContext starter method.
//var securitySystem = SecurityContextForConcurrencyTests.StartTheSystem(new SecurityConfiguration
//{
// SecurityDataProvider = securityDataProvider,
// MessageProvider = new DefaultMessageProvider(messageSenderManager),
// CommunicationMonitorRunningPeriodInSeconds = 31
//});
var config = new SecurityConfiguration();
var messagingOptions = new MessagingOptions {
CommunicationMonitorRunningPeriodInSeconds = 31
};
var securitySystem = new SecuritySystem(securityDataProvider,
new DefaultMessageProvider(messageSenderManager),
new MissingEntityHandler(), config, messagingOptions);
securitySystem.Start();
// legacy logic
// original line: MessageSender.Initialize("asdf");
//securitySystem.MessageSenderManager = messageSenderManager;
return(securitySystem);
}
public void WhenStartedWithOneSenderManagerIsIdle()
{
var listeningEvent = new ManualResetEventSlim();
var closeSocketEvent = new ManualResetEventSlim();
var serverTask = Server.CreateServer(4998, listeningEvent,
listener =>
{
var socket = listener.Accept();
// receive data hello and reply
var buffer = new byte[256];
var bytesReceived = socket.Receive(buffer);
if (bytesReceived == 2 && buffer[0] == MessageTypes.DataHello)
{
socket.Send(new[] { MessageTypes.DataHelloReply });
}
closeSocketEvent.Wait();
socket.Shutdown(SocketShutdown.Both);
socket.Close();
});
if (!listeningEvent.Wait(5000))
{
Assert.Fail("Expected server to start listening");
}
var socketFactory = new SocketFactory("127.0.0.1", 4998, 1);
// act
var logger = new Mock <ILog>().Object;
var messageSenderManager = new MessageSenderManager(socketFactory,
new DataConnectionHandshake(new MessageProtocol()),
new BufferPool(1, 9, logger),
1,
1,
new ErrorHandler(),
logger);
// assert
Assert.IsTrue(messageSenderManager.IsIdle);
Assert.AreEqual(1, messageSenderManager.CurrentConnectionCount);
Assert.AreEqual(1, messageSenderManager.CurrentSenderCount);
messageSenderManager.Shutdown();
Assert.IsTrue(messageSenderManager.IsShutdown);
closeSocketEvent.Set();
serverTask.Wait();
serverTask.Dispose();
}
public void Messaging_BigActivity()
{
SnLog.Instance = new TestLogger();
//---- Ensure test data
var entities = CreateTestEntities();
var groups = SystemStartTests.CreateTestGroups();
var memberships = Tools.CreateInMemoryMembershipTable(groups);
var aces = CreateTestAces();
var storage = new DatabaseStorage
{
Aces = aces,
Memberships = memberships,
Entities = entities,
Messages = new List <Tuple <int, DateTime, byte[]> >()
};
//---- Start the system
var messageSenderManager = new MessageSenderManager();
var msgProvider = new TestMessageProvider(messageSenderManager);
msgProvider.Initialize();
var securitySystem = Context.StartTheSystem(new MemoryDataProviderForMessagingTests(storage), msgProvider);
_context = new Context(TestUser.User1, securitySystem);
// small activity
var smallActivity = new TestActivity();
smallActivity.Execute(_context.Security);
var smallActivityId = smallActivity.Id;
// large activity
var largeActivity = new TestActivity {
Body = new string('*', securitySystem.MessagingOptions.DistributableSecurityActivityMaxSize + 1)
};
largeActivity.Execute(_context.Security);
var largeActivityId = largeActivity.Id;
// check the logger
var expected = string.Format("Executing unprocessed security activities., " +
"Send: TestActivity, Applied: #{0}, " +
"Send: BigActivityMessage, LoadMessage: TestActivity#{1}, Applied: #{1}",
smallActivityId, largeActivityId);
var testLogger = (TestLogger)SnLog.Instance;
var actual = string.Join(", ", testLogger.InformationEvents);
Assert.AreEqual(expected, actual);
}
private int m_maxGenerateResetPasswordTokenRetries = 10; //TODO make configurable
public IdentityUserManager(UserManager userManager, UserContactManager userContactManager,
MessageSenderManager messageSenderManager, IUserStore <ApplicationUser> store,
IOptions <IdentityOptions> optionsAccessor, IPasswordHasher <ApplicationUser> passwordHasher,
IEnumerable <IUserValidator <ApplicationUser> > userValidators,
IEnumerable <IPasswordValidator <ApplicationUser> > passwordValidators, ILookupNormalizer keyNormalizer,
IdentityErrorDescriber errors, IServiceProvider services, ILogger <UserManager <ApplicationUser> > logger,
ITranslator translator) :
base(store, optionsAccessor, passwordHasher, userValidators, passwordValidators, keyNormalizer, errors,
services, logger)
{
m_userManager = userManager;
m_userContactManager = userContactManager;
m_messageSenderManager = messageSenderManager;
m_translator = translator;
}
public void Messaging_MessageSender()
{
SnLog.Instance = new TestLogger();
//---- Ensure test data
var entities = CreateTestEntities();
var groups = SystemStartTests.CreateTestGroups();
var memberships = Tools.CreateInMemoryMembershipTable(groups);
var aces = CreateTestAces();
var storage = new DatabaseStorage
{
Aces = aces,
Memberships = memberships,
Entities = entities,
Messages = new List <Tuple <int, DateTime, byte[]> >()
};
//---- Start the system
var messageSenderManager = new MessageSenderManager();
var msgProvider = new TestMessageProvider(messageSenderManager);
msgProvider.MessageReceived += MsgProvider_MessageReceived;
msgProvider.Initialize();
var securitySystem = Context.StartTheSystem(new MemoryDataProviderForMessagingTests(storage), msgProvider);
_context = new Context(TestUser.User1, securitySystem);
// small activity from me
var activity1 = new TestActivity();
activity1.Execute(_context.Security);
// small activity from another
var activity2 = new TestActivity
{
Sender = new TestMessageSender {
ComputerID = Environment.MachineName, InstanceID = "AnotherAppDomain"
}
};
activity2.Execute(_context.Security);
Assert.AreEqual("true, false", string.Join(", ", msgProvider.ReceiverMessages));
}
public IdentitySignInManager(
IdentityUserManager userManager, MessageSenderManager messageSenderManager,
IHttpContextAccessor contextAccessor,
IUserClaimsPrincipalFactory <ApplicationUser> claimsFactory,
IOptions <IdentityOptions> optionsAccessor,
ILogger <SignInManager <ApplicationUser> > logger,
IAuthenticationSchemeProvider schemes,
MessageSenderTokenProviderAssociationManager messageSenderTokenProviderAssociationManager,
IOptions <IdentityOptions> identityOptions,
ITranslator translator
) : base(
userManager, contextAccessor,
claimsFactory, optionsAccessor, logger, schemes)
{
m_userManager = userManager;
m_messageSenderManager = messageSenderManager;
m_messageSenderTokenProviderAssociationManager = messageSenderTokenProviderAssociationManager;
m_translator = translator;
m_tokenOptions = identityOptions.Value.Tokens;
m_defaultProvider = ResolveDefaultTokenProvider();
}
private SecuritySystem CreateSecuritySystem(string instanceName, Queue <byte[]> messageQueue, bool isReceiver)
{
var entities = SystemStartTests.CreateTestEntities();
var groups = SystemStartTests.CreateTestGroups();
var memberships = Tools.CreateInMemoryMembershipTable(groups);
var aces = SystemStartTests.CreateTestAces();
var storage = new DatabaseStorage {
Aces = aces, Memberships = memberships, Entities = entities, Messages = new List <Tuple <int, DateTime, byte[]> >()
};
var messageSenderManager = new MessageSenderManager(null, instanceName);
var securitySystem = new SecuritySystem(
new MemoryDataProvider(storage),
new TestMessageProvider(messageSenderManager, messageQueue, isReceiver),
new MissingEntityHandler(),
new SecurityConfiguration(),
new MessagingOptions());
securitySystem.Start();
return(securitySystem);
}
public void WhenNoConnectionErrorOccursWithShutdown()
{
var socketFactory = new SocketFactory("127.0.0.1", 4998, 1);
string errorMessage = null;
string exceptionMessage = null;
var errorHandler = new ErrorHandler();
errorHandler.ErrorOccurred += (sender, tuple) => { errorMessage = tuple.Item1; exceptionMessage = tuple.Item2?.Message; };
// act
var messageSenderManager = new MessageSenderManager(socketFactory,
new DataConnectionHandshake(new MessageProtocol()),
new BufferPool(1, 9, new Mock <ILog>().Object),
1,
1,
errorHandler,
new Mock <ILog>().Object);
// assert
Assert.IsTrue(messageSenderManager.IsShutdown);
Assert.AreEqual("Failed to open HQ Data connection to host 127.0.0.1 on port 4998 with a retry of 1 millisecond(s).", errorMessage);
Assert.IsNull(exceptionMessage);
}
static void Main(string[] args)
{
args = new[] { TestType.Backup.ToString() };
if (args.Length == 0)
{
Console.WriteLine("Missing test type. Expected 'Backup', 'Restore', 'Validity' or 'Cancellation'.");
return;
}
if (!Enum.TryParse <TestType>(args[0], true, out _testType))
{
Console.WriteLine("Invalid test type. Expected 'Backup', 'Restore' or 'Validity'.");
return;
}
_serviceIndexDirectory = Path.GetFullPath($"{Environment.CurrentDirectory}\\..\\..\\..\\..\\..\\" +
//"SenseNet.Search.Lucene29.Centralized.Service\\" +
"SenseNet.Search.Lucene29.Centralized.GrpcService\\" +
"bin\\Debug\\netcoreapp3.1\\App_Data\\LocalIndex");
Console.WriteLine("IndexDirectory of the service: ");
Console.WriteLine(_serviceIndexDirectory);
_backupIndexDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "App_Data", "IndexBackup");
Console.WriteLine("Backup directory: ");
Console.WriteLine(_backupIndexDirectory);
IConfiguration configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", true, true)
.AddEnvironmentVariables()
.Build();
//var serviceBinding = new NetTcpBinding { Security = { Mode = SecurityMode.None } };
//var serviceEndpoint = new EndpointAddress(configuration["sensenet:search:service:address"]);
//WaitForServiceStarted(serviceBinding, serviceEndpoint);
var sender = new MessageSenderManager();
var builder = new RepositoryBuilder()
.SetConsole(Console.Out)
.UseLogger(new SnFileSystemEventLogger())
.UseTracer(new SnFileSystemTracer())
.UseConfiguration(configuration)
.UseDataProvider(new MsSqlDataProvider(Options.Create(ConnectionStringOptions.GetLegacyConnectionStrings())))
.UseSecurityDataProvider(new EFCSecurityDataProvider(sender,
Options.Create(new SenseNet.Security.EFCSecurityStore.Configuration.DataOptions()
{
ConnectionString = ConnectionStrings.ConnectionString
}),
NullLogger <EFCSecurityDataProvider> .Instance))
.UseSecurityMessageProvider(new RabbitMQMessageProvider(sender,
Options.Create(new MessagingOptions()),
Options.Create(new RabbitMqOptions())))
.UseLucene29CentralizedSearchEngineWithGrpc(configuration["sensenet:search:service:address"], options =>
{
// trust the server in a development environment
options.HttpClient = new HttpClient(new HttpClientHandler
{
ServerCertificateCustomValidationCallback = (message, certificate2, arg3, arg4) => true
});
options.DisposeHttpClient = true;
})
.StartWorkflowEngine(false)
.DisableNodeObservers()
.UseTraceCategories(SnTrace.Categories.Select(x => x.Name).ToArray()) as RepositoryBuilder;
using (Repository.Start(builder))
{
Console.WriteLine("CHECK SQL SERVER CONNECTIVITY (query top level nodes):");
var root = Node.LoadNode(Repository.RootPath);
foreach (var node in NodeQuery.QueryChildren(Repository.RootPath).Nodes)
{
Console.WriteLine(node.Path);
}
Console.WriteLine();
Console.WriteLine("CHECK SEARCH SERVER CONNECTIVITY (query top level nodes):");
var queryContext = new SnQueryContext(QuerySettings.AdminSettings, User.Current.Id);
var result = SnQuery.Query("InFolder:/Root", queryContext);
foreach (var id in result.Hits)
{
Console.WriteLine(NodeHead.Get(id).Path);
}
Console.WriteLine();
SnTrace.EnableAll();
var engine = (ILuceneIndexingEngine)Providers.Instance.SearchEngine.IndexingEngine;
switch (_testType)
{
case TestType.Backup:
new ContinuousIndexTest(engine).RunAsync(CancellationToken.None)
.ConfigureAwait(false).GetAwaiter().GetResult();
break;
case TestType.Restore:
new RestoreTest(engine).RunAsync(CancellationToken.None)
.ConfigureAwait(false).GetAwaiter().GetResult();
break;
case TestType.Validity:
new ValidityTest(engine).RunAsync(CancellationToken.None)
.ConfigureAwait(false).GetAwaiter().GetResult();
break;
case TestType.Cancellation:
new CancellationTest(engine).RunAsync(CancellationToken.None)
.ConfigureAwait(false).GetAwaiter().GetResult();
break;
default:
throw new ArgumentOutOfRangeException();
}
// Shut down the service to leave the index.
IndexManager.IndexingEngine.ShutDownAsync(CancellationToken.None)
.ConfigureAwait(false).GetAwaiter().GetResult();
}
}
public void WhenNoConnectionForOneOfTwoErrorOccursWithShutdown()
{
var listeningEvent = new ManualResetEventSlim();
var closeSocket1Event = new ManualResetEventSlim();
var closeSocket2Event = new ManualResetEventSlim();
var replyType = 0;
var serverTask = Server.CreateServer(4998, listeningEvent,
listener =>
{
var socket = listener.Accept();
Interlocked.Increment(ref replyType);
// receive data hello and reply
var buffer = new byte[256];
var bytesReceived = socket.Receive(buffer);
if (bytesReceived == 2 && buffer[0] == MessageTypes.DataHello)
{
socket.Send(new[] { replyType == 1 ? MessageTypes.DataHelloReply : (byte)0xFE });
}
// wait for socket close
closeSocket1Event.Wait();
socket.Shutdown(SocketShutdown.Both);
socket.Close();
},
listener =>
{
var socket = listener.Accept();
Interlocked.Increment(ref replyType);
// receive data hello and reply
var buffer = new byte[256];
var bytesReceived = socket.Receive(buffer);
if (bytesReceived == 2 && buffer[0] == MessageTypes.DataHello)
{
socket.Send(new[] { replyType == 1 ? MessageTypes.DataHelloReply : (byte)0xFE });
}
// wait for socket close
closeSocket2Event.Wait();
socket.Shutdown(SocketShutdown.Both);
socket.Close();
});
if (!listeningEvent.Wait(5000))
{
Assert.Fail("Expected server to start listening");
}
var socketFactory = new SocketFactory("127.0.0.1", 4998, 1);
string errorMessage = null;
string exceptionMessage = null;
var errorHandler = new ErrorHandler();
errorHandler.ErrorOccurred += (sender, tuple) => { errorMessage = tuple.Item1; exceptionMessage = tuple.Item2?.Message; };
// act
var messageSenderManager = new MessageSenderManager(socketFactory,
new DataConnectionHandshake(new MessageProtocol()),
new BufferPool(1, 9, new Mock <ILog>().Object),
2,
1,
errorHandler,
new Mock <ILog>().Object);
// assert
Assert.AreEqual(0, messageSenderManager.CurrentConnectionCount);
Assert.AreEqual(0, messageSenderManager.CurrentSenderCount);
Assert.IsTrue(messageSenderManager.IsShutdown);
Assert.AreEqual("Unable to perform data connection handshake.", errorMessage);
Assert.AreEqual("Handshake operation failed with unexpected reply: 254", exceptionMessage);
closeSocket1Event.Set();
closeSocket2Event.Set();
serverTask.Wait();
serverTask.Dispose();
}
