/// <summary>
/// Converts an <see cref="EmbeddedVNodeBuilder"/> to a <see cref="ClusterVNode"/>.
/// </summary>
public ClusterVNode Build()
{
EnsureHttpPrefixes();
SetUpProjectionsIfNeeded();
var dbConfig = CreateDbConfig(_chunkSize, _dbPath, _chunksCacheSize,
_inMemoryDb);
var db = new TFChunkDb(dbConfig);
var vNodeSettings = new ClusterVNodeSettings(Guid.NewGuid(),
0,
_internalTcp,
_internalSecureTcp,
_externalTcp,
_externalSecureTcp,
_internalHttp,
_externalHttp,
new GossipAdvertiseInfo(_internalTcp, _internalSecureTcp, _externalTcp, _externalSecureTcp, _internalHttp, _externalHttp),
_intHttpPrefixes.ToArray(),
_extHttpPrefixes.ToArray(),
_enableTrustedAuth,
_certificate,
_workerThreads,
_discoverViaDns,
_clusterDns,
_gossipSeeds.ToArray(),
_minFlushDelay,
_clusterNodeCount,
_prepareAckCount,
_commitAckCount,
_prepareTimeout,
_commitTimeout,
_useSsl,
_sslTargetHost,
_sslValidateServer,
_statsPeriod,
_statsStorage,
_nodePriority,
_authenticationProviderFactory,
_disableScavengeMerging,
_scavengeHistoryMaxAge,
_adminOnPublic,
_statsOnPublic,
_gossipOnPublic,
_gossipInterval,
_gossipAllowedTimeDifference,
_gossipTimeout,
_intTcpHeartbeatTimeout,
_intTcpHeartbeatInterval,
_extTcpHeartbeatTimeout,
_extTcpHeartbeatInterval,
!_skipVerifyDbHashes,
_maxMemtableSize,
_startStandardProjections,
_disableHTTPCaching,
_logHttpRequests);
var infoController = new InfoController(null, _projectionType);
return(new ClusterVNode(db, vNodeSettings, GetGossipSource(), infoController, _subsystems.ToArray()));
}
public void InfoController_GetInfo_UsesCorrectQueryLogicProvider()
{
//Arrange
var stubLogger = Substitute.For <ILogger>();
stubLogger.LogRequest(Arg.Any <Func <JToken> >(), Arg.Any <string>(), Arg.Any <object>()).Returns((callInfo) => callInfo.ArgAt <Func <JToken> >(0)());
var stubRepository = Substitute.For <IInfoRepository>();
stubRepository.GetInfoContext(Arg.Any <string>()).Returns(new InfoContext()
{
QueryLogicType = QueryLogicType.REST, QueryLogic = "someUri"
});
var stubQueryLogicProvider = Substitute.For <IQueryLogicResolver>();
stubQueryLogicProvider.PerformQuery("someUri", Arg.Any <string[]>()).Returns(JToken.Parse("\"aSampleResult\""));
var stubQueryLogicProviders = Substitute.For <IQueryLogicResolverFactory>();
stubQueryLogicProviders.getQueryLogicResolver(QueryLogicType.REST).Returns(stubQueryLogicProvider);
var target = new InfoController(stubRepository, stubQueryLogicProviders, stubLogger);
//Act
var result = target.GetInfo("someTestInfo", null);
var okResult = result as OkObjectResult;
//Assert
Assert.IsNotNull(okResult);
Assert.That(okResult.Value.ToString(), Is.EqualTo("aSampleResult"));
}
// Create buttons for each teacher on stage up.
void Start()
{
// Max of 8 teachers at once.
GameObject[] buttonArray = new GameObject[8];
ic = (InfoController)FindObjectOfType(typeof(InfoController));
teachers = ic.getTeachers();
//DEBUG_PACKS();
for (int i = 0; i < teachers.Length; i++)
{
var fix = i;
buttonArray[i] = Instantiate(buttonPrefab) as GameObject;
buttonArray[i].transform.SetParent(canvas.transform);
// Perform trig to make teacher's things appear as buttons
float c = 360 / teachers.Length;
float xcord = Mathf.Cos(c * i * Mathf.Deg2Rad + Mathf.PI / 2) * Screen.height / 4;
float ycord = Mathf.Sin(c * i * Mathf.Deg2Rad + Mathf.PI / 2) * Screen.height / 4;
buttonArray[i].transform.position = new Vector3(xcord + Screen.width / 2, ycord + Screen.height / 2, 0);
buttonArray[i].GetComponentInChildren <Text>().text = teachers[i];
buttonArray[i].GetComponent <Button>().onClick.AddListener(() => CallRequestContentPacks(teachers[fix]));
}
}
public void TestIfInfoIndexIsRedirect()
{
InfoController infoController = new InfoController();
var result = infoController.Index();
var viewResult = Assert.IsType <RedirectResult>(result);
}
public void InfoController_GetInfo_UsesParameters(string paramUrlSegments, string commaSeparatedParams)
{
//Arrange
var stubLogger = Substitute.For <ILogger>();
stubLogger.LogRequest(Arg.Any <Func <JToken> >(), Arg.Any <string>(), Arg.Any <object>()).Returns((callInfo) => callInfo.ArgAt <Func <JToken> >(0)());
var stubRepository = Substitute.For <IInfoRepository>();
stubRepository.GetInfoContext(Arg.Any <string>()).Returns(new InfoContext()
{
QueryLogicType = QueryLogicType.REST, QueryLogic = "someUri"
});
var mockQueryLogicProvider = Substitute.For <IQueryLogicResolver>();
var stubQueryLogicProviders = Substitute.For <IQueryLogicResolverFactory>();
stubQueryLogicProviders.getQueryLogicResolver(QueryLogicType.REST).Returns(mockQueryLogicProvider);
var target = new InfoController(stubRepository, stubQueryLogicProviders, stubLogger);
string[] paramArray = null;
if (paramUrlSegments != null)
{
paramArray = paramUrlSegments.Split(',');
}
//Act
var result = target.GetInfo("someTestInfo", paramUrlSegments);
//Assert
mockQueryLogicProvider.Received().PerformQuery(Arg.Any <string>(), Arg.Is <string[]>(prms => string.Join(",", prms) == commaSeparatedParams));
}
public void TestGetInfo_SouldReturnInfo()
{
var configuration = new Mock <IConfiguration>();
var subject = new InfoController(configuration.Object);
var response = ((ContentResult)subject.ApiInfo()).Content;
Assert.IsTrue(response.Contains("NET.Core Api REST service started!"));
}
private void PrintTeacherList()
{
InfoController ic = (InfoController)FindObjectOfType(typeof(InfoController));
for (int i = 0; i < ic.getTeachers().Length; i++)
{
Debug.Log(ic.getTeachers()[i]);
}
}
public async Task Get_TestAsync()
{
var controller = new InfoController(fMediator);
fMediator
.Send(Arg.Any <GetInfoRequest>(), Arg.Any <CancellationToken>())
.Returns(new InfoModel {
Version = "ver"
});
var result = await controller.GetAsync(default);
public async Task Index_Get_NotNull()
{
//arrange
_infoManager.GetLanguagesListAsync().Returns(_languageDtoList);
_infoController = new InfoController(_infoManager, _dataAdapter, _logger);
//act
var result = await _infoController.GetLanguagesList();
//assert
Assert.NotNull(result);
}
public void Info_Controller()
{
var infoController = new InfoController();
Assert.IsNotNull(infoController);
var result_Index = infoController.Index();
var result_Ping = infoController.Ping();
Assert.AreEqual("System.Web.Mvc.ViewResult", result_Index.str());
Assert.IsInstanceOf <ViewResult>(result_Index);
Assert.AreEqual("pong", result_Ping);
}
private void SetupControllers()
{
var homeCtrl = new HomeController();
var homeNav = new UINavigationController(homeCtrl);
homeNav.TabBarItem.SelectedImage = UIImage.FromBundle("HomeActive");
homeNav.TabBarItem.Image = UIImage.FromBundle("HomeDefault");
homeNav.TabBarItem.Title = "";
homeNav.TabBarItem.ImageInsets = new UIEdgeInsets(6, 0, -6, 0);
homeNav.NavigationBar.Translucent = false;
homeNav.NavigationBar.BarTintColor = MainColor;
homeNav.NavigationBar.TintColor = UIColor.White;
homeNav.NavigationBar.TitleTextAttributes = new UIStringAttributes()
{
ForegroundColor = UIColor.White
};
var testListCtrl = new TestListController();
var testListNav = new UINavigationController(testListCtrl);
testListNav.TabBarItem.SelectedImage = UIImage.FromBundle("TestActive");
testListNav.TabBarItem.Image = UIImage.FromBundle("TestDefault");
testListNav.TabBarItem.Title = "";
testListNav.TabBarItem.ImageInsets = new UIEdgeInsets(6, 0, -6, 0);
testListNav.NavigationBar.Translucent = false;
testListNav.NavigationBar.BarTintColor = MainColor;
testListNav.NavigationBar.TintColor = UIColor.White;
testListNav.NavigationBar.TitleTextAttributes = new UIStringAttributes()
{
ForegroundColor = UIColor.White
};
var infoCtrl = new InfoController();
var infoNav = new UINavigationController(infoCtrl);
infoNav.TabBarItem.SelectedImage = UIImage.FromBundle("UserActive");
infoNav.TabBarItem.Image = UIImage.FromBundle("UserDefault");
infoNav.TabBarItem.Title = "";
infoNav.TabBarItem.ImageInsets = new UIEdgeInsets(6, 0, -6, 0);
infoNav.NavigationBar.Translucent = false;
infoNav.NavigationBar.BarTintColor = MainColor;
infoNav.NavigationBar.TintColor = UIColor.White;
infoNav.NavigationBar.TitleTextAttributes = new UIStringAttributes()
{
ForegroundColor = UIColor.White
};
var navControllers = new UINavigationController[] { homeNav, testListNav, infoNav };
base.ViewControllers = navControllers;
base.SelectedIndex = 1;
}
public void CategoryTest()
{
// Arrange
// Макет репозитория
var mock = new Mock <IRepository <Movie> >();
mock.Setup(r => r.GetAll())
.Returns(new List <Movie>
{
new Movie {
MovieId = 1, MovieName = "Movie1", GroupName = "1"
},
new Movie {
MovieId = 2, MovieName = "Movie2", GroupName = "2"
},
new Movie {
MovieId = 3, MovieName = "Movie3", GroupName = "1"
},
new Movie {
MovieId = 4, MovieName = "Movie4", GroupName = "2"
},
new Movie {
MovieId = 5, MovieName = "Movie5", GroupName = "2"
},
});
// Макеты для получения HttpContext HttpRequest
var request = new Mock <HttpRequestBase>();
var httpContext = new Mock <HttpContextBase>();
httpContext.Setup(h => h.Request).Returns(request.Object);
// Создание объекта контроллера
var controller = new InfoController(mock.Object);
// Создание контекста контроллера
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = httpContext.Object;
// Act
// Вызов метода List
var view = controller.Index("1", 1) as ViewResult;
// Assert
Assert.IsNotNull(view, "Представление не получено");
Assert.IsNotNull(view.Model, "Модель не получена");
PageListViewModel <Movie> model = view.Model as PageListViewModel <Movie>;
Assert.AreEqual(2, model.Count);
Assert.AreEqual(1, model[0].MovieId);
Assert.AreEqual(3, model[1].MovieId);
}
public void IndexGet()
{
var film = new Film()
{
Name = "AppTesting",
Actors = new[] { new Actor()
{
Name = "Me"
}, new Actor()
{
Name = "TestWebApp"
} },
Year = 2016,
Genre = Genre.Drama
};
using (var context = new Context(Context.Type.TestDatabase))
{
context.Films.Add(film);
context.SaveChanges();
var amountOfFilms = context.Films.Count();
using (var infoController = new InfoController(context))
{
var view = infoController.Index((int)film.ID) as ViewResult;
film = view?.Model as Film;
Assert.IsNotNull(film);
Assert.AreEqual("AppTesting", film.Name);
Assert.AreEqual((short)2016, film.Year);
Assert.AreEqual(Genre.Drama, film.Genre);
Assert.IsNotNull(film.Actors);
Assert.AreEqual(2, film.Actors.Count);
Assert.IsTrue(film.Actors.Any(a => a.Name == "Me"));
Assert.IsTrue(film.Actors.Any(a => a.Name == "TestWebApp"));
view = infoController.Index() as ViewResult;
Assert.IsNotNull(view);
Assert.AreEqual("Error", view.ViewName);
view = infoController.Index(amountOfFilms + 1) as ViewResult;
Assert.IsNotNull(view);
Assert.AreEqual("Error", view.ViewName);
}
}
}
private void describe_()
{
describe[Controller.Index] = () =>
{
Mock <IContainerInfoService> mockContainerService = null;
string handle = "container-handle";
InfoController controller = null;
IHttpActionResult result = null;
before = () =>
{
mockContainerService = new Mock <IContainerInfoService>();
controller = new InfoController(mockContainerService.Object);
};
act = () => result = controller.GetInfo(handle);
context["when the container exists"] = () =>
{
ContainerInfo info = null;
before = () =>
{
info = new ContainerInfo();
mockContainerService.Setup(x => x.GetInfoByHandle(handle))
.Returns(info);
};
it["returns info about the container"] = () =>
{
var jsonResult = result.should_cast_to <JsonResult <ContainerInfo> >();
jsonResult.Content.should_be(info);
};
};
context["when the container does not exist"] = () =>
{
before = () =>
{
mockContainerService.Setup(x => x.GetInfoByHandle(handle))
.Returns((ContainerInfo)null);
};
it["returns not found"] = () =>
{
result.should_cast_to <NotFoundResult>();
};
};
};
}
private void Start()
{
_events = FindObjectOfType <EventsController>();
_waveController = FindObjectOfType <WaveController>();
_currencyController = FindObjectOfType <CurrencyController>();
_attackerSpawners = FindObjectsOfType <AttackerSpawner>();
_heatZones = FindObjectOfType <HeatZones>();
_infoController = FindObjectOfType <InfoController>();
_boardEvents = FindObjectOfType <BoardEvents>();
_cooldownCounterReset();
StartCoroutine(_firstEvent());
}
public StandardTradeToolController()
{
infoModel = new InfoModel();
/* Add info messages */
infoModel.infoMessageList.Add(new InfoMessage(
EInfoMessageId.EntryGreaterThanTicker,
"Entry price is greater than ticker." + " Entrance price: " + exchangeDataModel.EntrancePrice + " Ticker price: " + exchangeDataModel.TickerPrice + " Date/Time: " + DateTime.Now)
);
infoModel.infoMessageList.Add(new InfoMessage(
EInfoMessageId.EntryLessThanTicker,
"Entry price is less than ticker." + " Entrance price: " + exchangeDataModel.EntrancePrice + " Ticker price: " + exchangeDataModel.TickerPrice + " Date/Time: " + DateTime.Now)
);
infoModel.infoMessageList.Add(new InfoMessage(
EInfoMessageId.DetectEntrance,
"Detecting trade entrance." + " Ticker price: " + exchangeDataModel.TickerPrice + " Date/Time: " + DateTime.Now)
);
infoModel.infoMessageList.Add(new InfoMessage(
EInfoMessageId.DetectExit,
"Detecting trade exit." + " Ticker price: " + exchangeDataModel.TickerPrice + " Date/Time: " + DateTime.Now)
);
infoModel.infoMessageList.Add(new InfoMessage(
EInfoMessageId.BuyOrderEnteredEntryGreaterThanTicker,
"Trade was entered (BUY ORDER) with entry originally greater than ticker." + " Entrance price: " + exchangeDataModel.EntrancePrice + " TickerPrice: " + exchangeDataModel.TickerPrice + " Date/Time: " + DateTime.Now)
);
infoModel.infoMessageList.Add(new InfoMessage(
EInfoMessageId.BuyOrderEnteredEntryLessThanTicker,
"Trade was entered (BUY ORDER) with entry originally less than ticker." + " Entrance price: " + exchangeDataModel.EntrancePrice + " TickerPrice: " + exchangeDataModel.TickerPrice + " Date/Time: " + DateTime.Now)
);
infoModel.infoMessageList.Add(new InfoMessage(
EInfoMessageId.SellOrderEnteredEntryGreaterThanTicker,
"Trade was entered (SELL ORDER) with entry originally greater than ticker." + " Entrance price: " + exchangeDataModel.EntrancePrice + " TickerPrice: " + exchangeDataModel.TickerPrice + " Date/Time: " + DateTime.Now)
);
infoModel.infoMessageList.Add(new InfoMessage(
EInfoMessageId.SellOrderEnteredEntryLessThanTicker,
"Trade was entered (SELL ORDER) with entry originally less than ticker." + " Entrance price: " + exchangeDataModel.EntrancePrice + " TickerPrice: " + exchangeDataModel.TickerPrice + " Date/Time: " + DateTime.Now)
);
infoModel.infoMessageList.Add(new InfoMessage(
EInfoMessageId.ExitedWithProfit,
"Trade was exited with a profit." + " Target profit price: " + exchangeDataModel.ProfitTargetPrice + " TickerPrice: " + exchangeDataModel.TickerPrice + " Date/Time: " + DateTime.Now)
);
infoModel.infoMessageList.Add(new InfoMessage(
EInfoMessageId.ExitedWithLoss,
"Trade was exited with a loss." + " Stop loss price: " + exchangeDataModel.StopLossPrice + " TickerPrice: " + exchangeDataModel.TickerPrice + " Date/Time: " + DateTime.Now)
);
infoController = new InfoController(infoModel, @"E:\Test.txt");
}
public void OnEnable()
{
if (Network.peerType != NetworkPeerType.Server)
{
return;
}
setupPlayer(true);
percentage = 100;
GameObject aux = GameObject.Find("Info");
if (aux != null)
{
info = aux.gameObject.GetComponent <InfoController>();
}
player = this.gameObject.GetComponent <MovementController> ();
if (info != null && player != null)
{
info.setLife(percentage);
}
if (gameObject.layer == 12)
{
return;
}
switch (team)
{
case 1:
transform.position = GameObject.FindGameObjectsWithTag("Respawn")[0].GetComponent <SpawnManager>().giveRespawnIzq();
break;
case 2:
transform.position = GameObject.FindGameObjectsWithTag("Respawn")[0].GetComponent <SpawnManager>().giveRespawnDer();
break;
case 5:
transform.position = GameObject.FindGameObjectsWithTag("Respawn")[0].GetComponent <SpawnManager>().giveRespawnIA();
break;
}
;
}
public void Hurt(int damage)
{
Debug.Log("uuuuh me hacen daño y tengo " + gameObject);
percentage -= damage;
if (this.tag == "Player")
{
this.gameObject.networkView.RPC("setLife", RPCMode.Others, percentage);
}
//UpColorGO.gameObject.GetComponent<SpriteRenderer> ().material.color = Color.red;
if (percentage <= 0)
{
setupPlayer(false);
Debug.Log("voy a hacer setlife");
if (this.tag == "Player")
{
this.gameObject.networkView.RPC("setLife", RPCMode.Others, percentage);
}
Debug.Log("termino setlife");
Invoke("OnEnable", 5.0f);
}
if (info != null)
{
info = GameObject.Find("Info").gameObject.GetComponent <InfoController>();
}
if (player != null && info != null)
{
info.setLife(percentage);
}
/*
*
* Hashtable tweenParams = new Hashtable();
* tweenParams.Add("from", Color.red);
* tweenParams.Add("to", UpColor);
* tweenParams.Add("time", 4.0f);
* tweenParams.Add ("easetype", iTween.EaseType.easeInBack);
* tweenParams.Add ("includeChildren", true);
*
* iTween.ValueTo(player.DownSpriteGo, tweenParams);
*
*/
}
public void GitHubUserInfoTest()
{
//Arrange
var searchUser = "******";
var infoController = new InfoController();
//Act
ActionResult result = infoController.GitHubUserInfo(searchUser);
//Assert
Assert.IsInstanceOfType(result, typeof(PartialViewResult));
//Verify the result model type
ViewResult vResult = result as ViewResult;
if (vResult != null)
{
Assert.IsInstanceOfType(vResult.Model, typeof(DataModels.Info));
}
}
public void InfoController_GetInfo_LogsRequests()
{
//Arrange
var mockLogger = Substitute.For <ILogger>();
var stubRepository = Substitute.For <IInfoRepository>();
stubRepository.GetInfoContext(Arg.Any <string>()).Returns(new InfoContext()
{
QueryLogicType = QueryLogicType.REST, QueryLogic = "someUri"
});
var stubQueryLogicProvider = Substitute.For <IQueryLogicResolver>();
var stubQueryLogicProviders = Substitute.For <IQueryLogicResolverFactory>();
stubQueryLogicProviders.getQueryLogicResolver(QueryLogicType.REST).Returns(stubQueryLogicProvider);
var target = new InfoController(stubRepository, stubQueryLogicProviders, mockLogger);
//Act
var result = target.GetInfo("someTestInfo", null);
//Assert
mockLogger.Received().LogRequest(Arg.Any <Func <JToken> >(), "someTestInfo", Arg.Is <object>(prm => true));
}
public async Task Get_ReturnsInfo()
{
// arrange
var dataStructureConverterMoq = new Mock <IDataStructureConverter>();
dataStructureConverterMoq.Setup(x => x.Convert(It.IsAny <string>(), It.IsAny <object>()))
.Returns(new Dictionary <string, object>
{
{ "data", InfoHelper.Get() }
});
var sut = new InfoController(dataStructureConverterMoq.Object);
// act
var response = await sut.Get();
var result = response as OkObjectResult;
// assert
Assert.NotNull(result);
}
IEnumerator LoginPlayer()
{
WWWForm form = new WWWForm();
form.AddField("name", nameField.text);
form.AddField("password", SHA256(passwordField.text));
WWW www = new WWW("http://localhost/sqlconnect/login.php", form);
yield return(www);
if (www.text == "1")
{
Debug.Log("Error communicating with the database");
}
else if (www.text == "2")
{
Debug.Log("Either your username or password is incorrect");
}
else if (www.text == string.Empty)
{
Debug.Log("Unable to connect to the server");
}
else
{
Debug.Log("User login successful!");
Debug.Log(www.text);
//Get the 'global' controller for storing objects
InfoController ic = (InfoController)FindObjectOfType(typeof(InfoController));
ic.setTeachers(www.text);
ic.setUsername(nameField.text);
UnityEngine.SceneManagement.SceneManager.LoadScene(3);
}
}
public async Task Get_ReturnsVersion()
{
// arrange
var dataStructureConverterMoq = new Mock <IDataStructureConverter>();
dataStructureConverterMoq.Setup(x => x.Convert(It.IsAny <string>(), It.IsAny <object>()))
.Returns(new Dictionary <string, object>
{
{ "data", InfoHelper.Get() }
});
var sut = new InfoController(dataStructureConverterMoq.Object);
// act
var response = await sut.Get();
var result = response as OkObjectResult;
var resultValue = (Dictionary <string, object>)result.Value;
var infoResult = (ApiInfoModel)resultValue["data"];
// assert
Assert.True(infoResult.Version.Length > 0);
}
public void Test_GetLastName_Controller()
{
var testctrlr = new InfoController();
Assert.NotNull(testctrlr.getLastName("Test"));
}
void Start()
{
m = this;
infoPanel.SetActive(false);
}
public void EditMetadataRow(InfoController.CustomHeaderEntry headerEntry, bool selectValue)
{
foreach (DataGridViewRow row in metadataDataGridView.Rows)
{
if (row.DataBoundItem == headerEntry)
{
metadataDataGridView.CurrentCell = selectValue
? row.Cells[MetadataColumName.Value.ToString()]
: row.Cells[MetadataColumName.Name.ToString()];
break;
}
}
metadataDataGridView.BeginEdit(true);
}
protected override void Create(ClusterNodeOptions opts)
{
var dbPath = opts.Db;
if (!opts.MemDb)
{
_dbLock = new ExclusiveDbLock(dbPath);
if (!_dbLock.Acquire())
{
throw new Exception(string.Format("Couldn't acquire exclusive lock on DB at '{0}'.", dbPath));
}
}
_clusterNodeMutex = new ClusterNodeMutex();
if (!_clusterNodeMutex.Acquire())
{
throw new Exception(string.Format("Couldn't acquire exclusive Cluster Node mutex '{0}'.", _clusterNodeMutex.MutexName));
}
var dbConfig = CreateDbConfig(dbPath, opts.CachedChunks, opts.ChunksCacheSize, opts.MemDb);
FileStreamExtensions.ConfigureFlush(disableFlushToDisk: opts.UnsafeDisableFlushToDisk);
var db = new TFChunkDb(dbConfig);
var vNodeSettings = GetClusterVNodeSettings(opts);
IGossipSeedSource gossipSeedSource;
if (opts.DiscoverViaDns)
{
gossipSeedSource = new DnsGossipSeedSource(opts.ClusterDns, opts.ClusterGossipPort);
}
else
{
if (opts.GossipSeed.Length == 0)
{
if (opts.ClusterSize > 1)
{
Log.Error("DNS discovery is disabled, but no gossip seed endpoints have been specified. "
+ "Specify gossip seeds using the --gossip-seed command line option.");
}
else
{
Log.Info("DNS discovery is disabled, but no gossip seed endpoints have been specified. Since"
+ "the cluster size is set to 1, this may be intentional. Gossip seeds can be specified"
+ "seeds using the --gossip-seed command line option.");
}
}
gossipSeedSource = new KnownEndpointGossipSeedSource(opts.GossipSeed);
}
var runProjections = opts.RunProjections;
Log.Info("{0,-25} {1}", "INSTANCE ID:", vNodeSettings.NodeInfo.InstanceId);
Log.Info("{0,-25} {1}", "DATABASE:", db.Config.Path);
Log.Info("{0,-25} {1} (0x{1:X})", "WRITER CHECKPOINT:", db.Config.WriterCheckpoint.Read());
Log.Info("{0,-25} {1} (0x{1:X})", "CHASER CHECKPOINT:", db.Config.ChaserCheckpoint.Read());
Log.Info("{0,-25} {1} (0x{1:X})", "EPOCH CHECKPOINT:", db.Config.EpochCheckpoint.Read());
Log.Info("{0,-25} {1} (0x{1:X})", "TRUNCATE CHECKPOINT:", db.Config.TruncateCheckpoint.Read());
var enabledNodeSubsystems = runProjections >= ProjectionType.System
? new[] { NodeSubsystems.Projections }
: new NodeSubsystems[0];
_projections = new Projections.Core.ProjectionsSubsystem(opts.ProjectionThreads, opts.RunProjections, opts.StartStandardProjections);
var infoController = new InfoController(opts, opts.RunProjections);
_node = new ClusterVNode(db, vNodeSettings, gossipSeedSource, infoController, _projections);
RegisterWebControllers(enabledNodeSubsystems, vNodeSettings);
}
public void EditAclRow(InfoController.UserAndRoleEntry aclEntry, bool selectRole)
{
foreach (DataGridViewRow row in aclDataGridView.Rows)
{
if (row.DataBoundItem == aclEntry)
{
aclDataGridView.CurrentCell = selectRole
? row.Cells[AclColumnName.Role.ToString()]
: row.Cells[AclColumnName.User.ToString()];
break;
}
}
aclDataGridView.BeginEdit(true);
}
public InfoControllerTests()
{
_controller = new InfoController();
}
//this function is called when create soldier button is clicked on information view.
public void CreateSoldierOnMap()
{
InfoController.Instance().CreateSoldierOnMap();
}
public ClusterVNode(TFChunkDb db,
ClusterVNodeSettings vNodeSettings,
IGossipSeedSource gossipSeedSource,
InfoController infoController,
params ISubsystem[] subsystems)
{
Ensure.NotNull(db, "db");
Ensure.NotNull(vNodeSettings, "vNodeSettings");
Ensure.NotNull(gossipSeedSource, "gossipSeedSource");
#if DEBUG
AddTask(_taskAddedTrigger.Task);
#endif
var isSingleNode = vNodeSettings.ClusterNodeCount == 1;
_nodeInfo = vNodeSettings.NodeInfo;
_mainBus = new InMemoryBus("MainBus");
var forwardingProxy = new MessageForwardingProxy();
if (vNodeSettings.EnableHistograms)
{
HistogramService.CreateHistograms();
//start watching jitter
HistogramService.StartJitterMonitor();
}
// MISC WORKERS
_workerBuses = Enumerable.Range(0, vNodeSettings.WorkerThreads).Select(queueNum =>
new InMemoryBus(string.Format("Worker #{0} Bus", queueNum + 1),
watchSlowMsg: true,
slowMsgThreshold: TimeSpan.FromMilliseconds(200))).ToArray();
_workersHandler = new MultiQueuedHandler(
vNodeSettings.WorkerThreads,
queueNum => new QueuedHandlerThreadPool(_workerBuses[queueNum],
string.Format("Worker #{0}", queueNum + 1),
groupName: "Workers",
watchSlowMsg: true,
slowMsgThreshold: TimeSpan.FromMilliseconds(200)));
_subsystems = subsystems;
_controller = new ClusterVNodeController((IPublisher)_mainBus, _nodeInfo, db, vNodeSettings, this, forwardingProxy, _subsystems);
_mainQueue = QueuedHandler.CreateQueuedHandler(_controller, "MainQueue");
_controller.SetMainQueue(_mainQueue);
//SELF
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(this);
_mainBus.Subscribe <SystemMessage.BecomeShutdown>(this);
// MONITORING
var monitoringInnerBus = new InMemoryBus("MonitoringInnerBus", watchSlowMsg: false);
var monitoringRequestBus = new InMemoryBus("MonitoringRequestBus", watchSlowMsg: false);
var monitoringQueue = new QueuedHandlerThreadPool(monitoringInnerBus, "MonitoringQueue", true, TimeSpan.FromMilliseconds(100));
var monitoring = new MonitoringService(monitoringQueue,
monitoringRequestBus,
_mainQueue,
db.Config.WriterCheckpoint,
db.Config.Path,
vNodeSettings.StatsPeriod,
_nodeInfo.ExternalHttp,
vNodeSettings.StatsStorage,
_nodeInfo.ExternalTcp,
_nodeInfo.ExternalSecureTcp);
_mainBus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.SystemInit, Message>());
_mainBus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.StateChangeMessage, Message>());
_mainBus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.BecomeShuttingDown, Message>());
_mainBus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.BecomeShutdown, Message>());
_mainBus.Subscribe(monitoringQueue.WidenFrom <ClientMessage.WriteEventsCompleted, Message>());
monitoringInnerBus.Subscribe <SystemMessage.SystemInit>(monitoring);
monitoringInnerBus.Subscribe <SystemMessage.StateChangeMessage>(monitoring);
monitoringInnerBus.Subscribe <SystemMessage.BecomeShuttingDown>(monitoring);
monitoringInnerBus.Subscribe <SystemMessage.BecomeShutdown>(monitoring);
monitoringInnerBus.Subscribe <ClientMessage.WriteEventsCompleted>(monitoring);
monitoringInnerBus.Subscribe <MonitoringMessage.GetFreshStats>(monitoring);
monitoringInnerBus.Subscribe <MonitoringMessage.GetFreshTcpConnectionStats>(monitoring);
var truncPos = db.Config.TruncateCheckpoint.Read();
if (truncPos != -1)
{
Log.Info("Truncate checkpoint is present. Truncate: {0} (0x{0:X}), Writer: {1} (0x{1:X}), Chaser: {2} (0x{2:X}), Epoch: {3} (0x{3:X})",
truncPos, db.Config.WriterCheckpoint.Read(), db.Config.ChaserCheckpoint.Read(), db.Config.EpochCheckpoint.Read());
var truncator = new TFChunkDbTruncator(db.Config);
truncator.TruncateDb(truncPos);
}
// STORAGE SUBSYSTEM
db.Open(vNodeSettings.VerifyDbHash);
var indexPath = vNodeSettings.Index ?? Path.Combine(db.Config.Path, "index");
var readerPool = new ObjectPool <ITransactionFileReader>(
"ReadIndex readers pool", ESConsts.PTableInitialReaderCount, ESConsts.PTableMaxReaderCount,
() => new TFChunkReader(db, db.Config.WriterCheckpoint, optimizeReadSideCache: db.Config.OptimizeReadSideCache));
var tableIndex = new TableIndex(indexPath,
new XXHashUnsafe(),
new Murmur3AUnsafe(),
() => new HashListMemTable(vNodeSettings.IndexBitnessVersion, maxSize: vNodeSettings.MaxMemtableEntryCount * 2),
() => new TFReaderLease(readerPool),
vNodeSettings.IndexBitnessVersion,
maxSizeForMemory: vNodeSettings.MaxMemtableEntryCount,
maxTablesPerLevel: 2,
inMem: db.Config.InMemDb,
skipIndexVerify: vNodeSettings.SkipIndexVerify,
indexCacheDepth: vNodeSettings.IndexCacheDepth);
var readIndex = new ReadIndex(_mainQueue,
readerPool,
tableIndex,
ESConsts.StreamInfoCacheCapacity,
Application.IsDefined(Application.AdditionalCommitChecks),
Application.IsDefined(Application.InfiniteMetastreams) ? int.MaxValue : 1,
vNodeSettings.HashCollisionReadLimit,
vNodeSettings.SkipIndexScanOnReads,
db.Config.ReplicationCheckpoint);
var writer = new TFChunkWriter(db);
var epochManager = new EpochManager(_mainQueue,
ESConsts.CachedEpochCount,
db.Config.EpochCheckpoint,
writer,
initialReaderCount: 1,
maxReaderCount: 5,
readerFactory: () => new TFChunkReader(db, db.Config.WriterCheckpoint, optimizeReadSideCache: db.Config.OptimizeReadSideCache));
epochManager.Init();
var storageWriter = new ClusterStorageWriterService(_mainQueue, _mainBus, vNodeSettings.MinFlushDelay,
db, writer, readIndex.IndexWriter, epochManager,
() => readIndex.LastCommitPosition); // subscribes internally
AddTasks(storageWriter.Tasks);
monitoringRequestBus.Subscribe <MonitoringMessage.InternalStatsRequest>(storageWriter);
var storageReader = new StorageReaderService(_mainQueue, _mainBus, readIndex, vNodeSettings.ReaderThreadsCount, db.Config.WriterCheckpoint);
_mainBus.Subscribe <SystemMessage.SystemInit>(storageReader);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(storageReader);
_mainBus.Subscribe <SystemMessage.BecomeShutdown>(storageReader);
monitoringRequestBus.Subscribe <MonitoringMessage.InternalStatsRequest>(storageReader);
var indexCommitterService = new IndexCommitterService(readIndex.IndexCommitter, _mainQueue, db.Config.ReplicationCheckpoint, db.Config.WriterCheckpoint, vNodeSettings.CommitAckCount);
AddTask(indexCommitterService.Task);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(indexCommitterService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(indexCommitterService);
_mainBus.Subscribe <StorageMessage.CommitAck>(indexCommitterService);
var chaser = new TFChunkChaser(db, db.Config.WriterCheckpoint, db.Config.ChaserCheckpoint, db.Config.OptimizeReadSideCache);
var storageChaser = new StorageChaser(_mainQueue, db.Config.WriterCheckpoint, chaser, indexCommitterService, epochManager);
AddTask(storageChaser.Task);
#if DEBUG
QueueStatsCollector.InitializeCheckpoints(
_nodeInfo.DebugIndex, db.Config.WriterCheckpoint, db.Config.ChaserCheckpoint);
#endif
_mainBus.Subscribe <SystemMessage.SystemInit>(storageChaser);
_mainBus.Subscribe <SystemMessage.SystemStart>(storageChaser);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(storageChaser);
// AUTHENTICATION INFRASTRUCTURE - delegate to plugins
_internalAuthenticationProvider = vNodeSettings.AuthenticationProviderFactory.BuildAuthenticationProvider(_mainQueue, _mainBus, _workersHandler, _workerBuses);
Ensure.NotNull(_internalAuthenticationProvider, "authenticationProvider");
{
// EXTERNAL TCP
if (!vNodeSettings.DisableInsecureTCP)
{
var extTcpService = new TcpService(_mainQueue, _nodeInfo.ExternalTcp, _workersHandler,
TcpServiceType.External, TcpSecurityType.Normal, new ClientTcpDispatcher(),
vNodeSettings.ExtTcpHeartbeatInterval, vNodeSettings.ExtTcpHeartbeatTimeout,
_internalAuthenticationProvider, null, vNodeSettings.ConnectionPendingSendBytesThreshold);
_mainBus.Subscribe <SystemMessage.SystemInit>(extTcpService);
_mainBus.Subscribe <SystemMessage.SystemStart>(extTcpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(extTcpService);
}
// EXTERNAL SECURE TCP
if (_nodeInfo.ExternalSecureTcp != null)
{
var extSecTcpService = new TcpService(_mainQueue, _nodeInfo.ExternalSecureTcp, _workersHandler,
TcpServiceType.External, TcpSecurityType.Secure, new ClientTcpDispatcher(),
vNodeSettings.ExtTcpHeartbeatInterval, vNodeSettings.ExtTcpHeartbeatTimeout,
_internalAuthenticationProvider, vNodeSettings.Certificate, vNodeSettings.ConnectionPendingSendBytesThreshold);
_mainBus.Subscribe <SystemMessage.SystemInit>(extSecTcpService);
_mainBus.Subscribe <SystemMessage.SystemStart>(extSecTcpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(extSecTcpService);
}
if (!isSingleNode)
{
// INTERNAL TCP
if (!vNodeSettings.DisableInsecureTCP)
{
var intTcpService = new TcpService(_mainQueue, _nodeInfo.InternalTcp, _workersHandler,
TcpServiceType.Internal, TcpSecurityType.Normal,
new InternalTcpDispatcher(),
vNodeSettings.IntTcpHeartbeatInterval, vNodeSettings.IntTcpHeartbeatTimeout,
_internalAuthenticationProvider, null, ESConsts.UnrestrictedPendingSendBytes);
_mainBus.Subscribe <SystemMessage.SystemInit>(intTcpService);
_mainBus.Subscribe <SystemMessage.SystemStart>(intTcpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(intTcpService);
}
// INTERNAL SECURE TCP
if (_nodeInfo.InternalSecureTcp != null)
{
var intSecTcpService = new TcpService(_mainQueue, _nodeInfo.InternalSecureTcp, _workersHandler,
TcpServiceType.Internal, TcpSecurityType.Secure,
new InternalTcpDispatcher(),
vNodeSettings.IntTcpHeartbeatInterval, vNodeSettings.IntTcpHeartbeatTimeout,
_internalAuthenticationProvider, vNodeSettings.Certificate, ESConsts.UnrestrictedPendingSendBytes);
_mainBus.Subscribe <SystemMessage.SystemInit>(intSecTcpService);
_mainBus.Subscribe <SystemMessage.SystemStart>(intSecTcpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(intSecTcpService);
}
}
}
SubscribeWorkers(bus =>
{
var tcpSendService = new TcpSendService();
// ReSharper disable RedundantTypeArgumentsOfMethod
bus.Subscribe <TcpMessage.TcpSend>(tcpSendService);
// ReSharper restore RedundantTypeArgumentsOfMethod
});
var httpAuthenticationProviders = new List <HttpAuthenticationProvider>
{
new BasicHttpAuthenticationProvider(_internalAuthenticationProvider),
};
if (vNodeSettings.EnableTrustedAuth)
{
httpAuthenticationProviders.Add(new TrustedHttpAuthenticationProvider());
}
httpAuthenticationProviders.Add(new AnonymousHttpAuthenticationProvider());
var httpPipe = new HttpMessagePipe();
var httpSendService = new HttpSendService(httpPipe, forwardRequests: true);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(httpSendService);
_mainBus.Subscribe(new WideningHandler <HttpMessage.SendOverHttp, Message>(_workersHandler));
SubscribeWorkers(bus =>
{
bus.Subscribe <HttpMessage.HttpSend>(httpSendService);
bus.Subscribe <HttpMessage.HttpSendPart>(httpSendService);
bus.Subscribe <HttpMessage.HttpBeginSend>(httpSendService);
bus.Subscribe <HttpMessage.HttpEndSend>(httpSendService);
bus.Subscribe <HttpMessage.SendOverHttp>(httpSendService);
});
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(infoController);
var adminController = new AdminController(_mainQueue, _workersHandler);
var pingController = new PingController();
var histogramController = new HistogramController();
var statController = new StatController(monitoringQueue, _workersHandler);
var atomController = new AtomController(httpSendService, _mainQueue, _workersHandler, vNodeSettings.DisableHTTPCaching);
var gossipController = new GossipController(_mainQueue, _workersHandler, vNodeSettings.GossipTimeout);
var persistentSubscriptionController = new PersistentSubscriptionController(httpSendService, _mainQueue, _workersHandler);
var electController = new ElectController(_mainQueue);
// HTTP SENDERS
gossipController.SubscribeSenders(httpPipe);
electController.SubscribeSenders(httpPipe);
// EXTERNAL HTTP
_externalHttpService = new HttpService(ServiceAccessibility.Public, _mainQueue, new TrieUriRouter(),
_workersHandler, vNodeSettings.LogHttpRequests, vNodeSettings.GossipAdvertiseInfo.AdvertiseExternalIPAs,
vNodeSettings.GossipAdvertiseInfo.AdvertiseExternalHttpPortAs, vNodeSettings.ExtHttpPrefixes);
_externalHttpService.SetupController(persistentSubscriptionController);
if (vNodeSettings.AdminOnPublic)
{
_externalHttpService.SetupController(adminController);
}
_externalHttpService.SetupController(pingController);
_externalHttpService.SetupController(infoController);
if (vNodeSettings.StatsOnPublic)
{
_externalHttpService.SetupController(statController);
}
_externalHttpService.SetupController(atomController);
if (vNodeSettings.GossipOnPublic)
{
_externalHttpService.SetupController(gossipController);
}
_externalHttpService.SetupController(histogramController);
_mainBus.Subscribe <SystemMessage.SystemInit>(_externalHttpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(_externalHttpService);
_mainBus.Subscribe <HttpMessage.PurgeTimedOutRequests>(_externalHttpService);
// INTERNAL HTTP
if (!isSingleNode)
{
_internalHttpService = new HttpService(ServiceAccessibility.Private, _mainQueue, new TrieUriRouter(),
_workersHandler, vNodeSettings.LogHttpRequests, vNodeSettings.GossipAdvertiseInfo.AdvertiseInternalIPAs,
vNodeSettings.GossipAdvertiseInfo.AdvertiseInternalHttpPortAs, vNodeSettings.IntHttpPrefixes);
_internalHttpService.SetupController(adminController);
_internalHttpService.SetupController(pingController);
_internalHttpService.SetupController(infoController);
_internalHttpService.SetupController(statController);
_internalHttpService.SetupController(atomController);
_internalHttpService.SetupController(gossipController);
_internalHttpService.SetupController(electController);
_internalHttpService.SetupController(histogramController);
_internalHttpService.SetupController(persistentSubscriptionController);
}
// Authentication plugin HTTP
vNodeSettings.AuthenticationProviderFactory.RegisterHttpControllers(_externalHttpService, _internalHttpService, httpSendService, _mainQueue, _workersHandler);
if (_internalHttpService != null)
{
_mainBus.Subscribe <SystemMessage.SystemInit>(_internalHttpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(_internalHttpService);
_mainBus.Subscribe <HttpMessage.PurgeTimedOutRequests>(_internalHttpService);
}
SubscribeWorkers(bus =>
{
HttpService.CreateAndSubscribePipeline(bus, httpAuthenticationProviders.ToArray());
});
// REQUEST FORWARDING
var forwardingService = new RequestForwardingService(_mainQueue, forwardingProxy, TimeSpan.FromSeconds(1));
_mainBus.Subscribe <SystemMessage.SystemStart>(forwardingService);
_mainBus.Subscribe <SystemMessage.RequestForwardingTimerTick>(forwardingService);
_mainBus.Subscribe <ClientMessage.NotHandled>(forwardingService);
_mainBus.Subscribe <ClientMessage.WriteEventsCompleted>(forwardingService);
_mainBus.Subscribe <ClientMessage.TransactionStartCompleted>(forwardingService);
_mainBus.Subscribe <ClientMessage.TransactionWriteCompleted>(forwardingService);
_mainBus.Subscribe <ClientMessage.TransactionCommitCompleted>(forwardingService);
_mainBus.Subscribe <ClientMessage.DeleteStreamCompleted>(forwardingService);
// REQUEST MANAGEMENT
var requestManagement = new RequestManagementService(_mainQueue,
vNodeSettings.PrepareAckCount,
vNodeSettings.PrepareTimeout,
vNodeSettings.CommitTimeout,
vNodeSettings.BetterOrdering);
_mainBus.Subscribe <SystemMessage.SystemInit>(requestManagement);
_mainBus.Subscribe <ClientMessage.WriteEvents>(requestManagement);
_mainBus.Subscribe <ClientMessage.TransactionStart>(requestManagement);
_mainBus.Subscribe <ClientMessage.TransactionWrite>(requestManagement);
_mainBus.Subscribe <ClientMessage.TransactionCommit>(requestManagement);
_mainBus.Subscribe <ClientMessage.DeleteStream>(requestManagement);
_mainBus.Subscribe <StorageMessage.RequestCompleted>(requestManagement);
_mainBus.Subscribe <StorageMessage.CheckStreamAccessCompleted>(requestManagement);
_mainBus.Subscribe <StorageMessage.AlreadyCommitted>(requestManagement);
_mainBus.Subscribe <StorageMessage.CommitReplicated>(requestManagement);
_mainBus.Subscribe <StorageMessage.PrepareAck>(requestManagement);
_mainBus.Subscribe <StorageMessage.WrongExpectedVersion>(requestManagement);
_mainBus.Subscribe <StorageMessage.InvalidTransaction>(requestManagement);
_mainBus.Subscribe <StorageMessage.StreamDeleted>(requestManagement);
_mainBus.Subscribe <StorageMessage.RequestManagerTimerTick>(requestManagement);
// SUBSCRIPTIONS
var subscrBus = new InMemoryBus("SubscriptionsBus", true, TimeSpan.FromMilliseconds(50));
var subscrQueue = new QueuedHandlerThreadPool(subscrBus, "Subscriptions", false);
_mainBus.Subscribe(subscrQueue.WidenFrom <SystemMessage.SystemStart, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <SystemMessage.BecomeShuttingDown, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <TcpMessage.ConnectionClosed, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <ClientMessage.SubscribeToStream, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <ClientMessage.UnsubscribeFromStream, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <SubscriptionMessage.PollStream, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <SubscriptionMessage.CheckPollTimeout, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <StorageMessage.EventCommitted, Message>());
var subscription = new SubscriptionsService(_mainQueue, subscrQueue, readIndex);
subscrBus.Subscribe <SystemMessage.SystemStart>(subscription);
subscrBus.Subscribe <SystemMessage.BecomeShuttingDown>(subscription);
subscrBus.Subscribe <TcpMessage.ConnectionClosed>(subscription);
subscrBus.Subscribe <ClientMessage.SubscribeToStream>(subscription);
subscrBus.Subscribe <ClientMessage.UnsubscribeFromStream>(subscription);
subscrBus.Subscribe <SubscriptionMessage.PollStream>(subscription);
subscrBus.Subscribe <SubscriptionMessage.CheckPollTimeout>(subscription);
subscrBus.Subscribe <StorageMessage.EventCommitted>(subscription);
// PERSISTENT SUBSCRIPTIONS
// IO DISPATCHER
var ioDispatcher = new IODispatcher(_mainQueue, new PublishEnvelope(_mainQueue));
_mainBus.Subscribe <ClientMessage.ReadStreamEventsBackwardCompleted>(ioDispatcher.BackwardReader);
_mainBus.Subscribe <ClientMessage.WriteEventsCompleted>(ioDispatcher.Writer);
_mainBus.Subscribe <ClientMessage.ReadStreamEventsForwardCompleted>(ioDispatcher.ForwardReader);
_mainBus.Subscribe <ClientMessage.DeleteStreamCompleted>(ioDispatcher.StreamDeleter);
_mainBus.Subscribe(ioDispatcher);
var perSubscrBus = new InMemoryBus("PersistentSubscriptionsBus", true, TimeSpan.FromMilliseconds(50));
var perSubscrQueue = new QueuedHandlerThreadPool(perSubscrBus, "PersistentSubscriptions", false);
_mainBus.Subscribe(perSubscrQueue.WidenFrom <SystemMessage.StateChangeMessage, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <TcpMessage.ConnectionClosed, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.CreatePersistentSubscription, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.UpdatePersistentSubscription, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.DeletePersistentSubscription, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.ConnectToPersistentSubscription, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.UnsubscribeFromStream, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.PersistentSubscriptionAckEvents, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.PersistentSubscriptionNackEvents, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.ReplayAllParkedMessages, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.ReplayParkedMessage, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.ReadNextNPersistentMessages, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <StorageMessage.EventCommitted, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <MonitoringMessage.GetAllPersistentSubscriptionStats, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <MonitoringMessage.GetStreamPersistentSubscriptionStats, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <MonitoringMessage.GetPersistentSubscriptionStats, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <SubscriptionMessage.PersistentSubscriptionTimerTick, Message>());
//TODO CC can have multiple threads working on subscription if partition
var consumerStrategyRegistry = new PersistentSubscriptionConsumerStrategyRegistry(_mainQueue, _mainBus, vNodeSettings.AdditionalConsumerStrategies);
var persistentSubscription = new PersistentSubscriptionService(perSubscrQueue, readIndex, ioDispatcher, _mainQueue, consumerStrategyRegistry);
perSubscrBus.Subscribe <SystemMessage.BecomeShuttingDown>(persistentSubscription);
perSubscrBus.Subscribe <SystemMessage.BecomeMaster>(persistentSubscription);
perSubscrBus.Subscribe <SystemMessage.StateChangeMessage>(persistentSubscription);
perSubscrBus.Subscribe <TcpMessage.ConnectionClosed>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.ConnectToPersistentSubscription>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.UnsubscribeFromStream>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.PersistentSubscriptionAckEvents>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.PersistentSubscriptionNackEvents>(persistentSubscription);
perSubscrBus.Subscribe <StorageMessage.EventCommitted>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.DeletePersistentSubscription>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.CreatePersistentSubscription>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.UpdatePersistentSubscription>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.ReplayAllParkedMessages>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.ReplayParkedMessage>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.ReadNextNPersistentMessages>(persistentSubscription);
perSubscrBus.Subscribe <MonitoringMessage.GetAllPersistentSubscriptionStats>(persistentSubscription);
perSubscrBus.Subscribe <MonitoringMessage.GetStreamPersistentSubscriptionStats>(persistentSubscription);
perSubscrBus.Subscribe <MonitoringMessage.GetPersistentSubscriptionStats>(persistentSubscription);
perSubscrBus.Subscribe <SubscriptionMessage.PersistentSubscriptionTimerTick>(persistentSubscription);
// STORAGE SCAVENGER
var scavengerLogManager = new TFChunkScavengerLogManager(_nodeInfo.ExternalHttp.ToString(), TimeSpan.FromDays(vNodeSettings.ScavengeHistoryMaxAge), ioDispatcher);
var storageScavenger = new StorageScavenger(db,
tableIndex,
readIndex,
scavengerLogManager,
vNodeSettings.AlwaysKeepScavenged,
!vNodeSettings.DisableScavengeMerging,
unsafeIgnoreHardDeletes: vNodeSettings.UnsafeIgnoreHardDeletes);
// ReSharper disable RedundantTypeArgumentsOfMethod
_mainBus.Subscribe <ClientMessage.ScavengeDatabase>(storageScavenger);
_mainBus.Subscribe <ClientMessage.StopDatabaseScavenge>(storageScavenger);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(storageScavenger);
// ReSharper restore RedundantTypeArgumentsOfMethod
// TIMER
_timeProvider = new RealTimeProvider();
var threadBasedScheduler = new ThreadBasedScheduler(_timeProvider);
AddTask(threadBasedScheduler.Task);
_timerService = new TimerService(threadBasedScheduler);
_mainBus.Subscribe <SystemMessage.BecomeShutdown>(_timerService);
_mainBus.Subscribe <TimerMessage.Schedule>(_timerService);
var gossipInfo = new VNodeInfo(_nodeInfo.InstanceId, _nodeInfo.DebugIndex,
vNodeSettings.GossipAdvertiseInfo.InternalTcp,
vNodeSettings.GossipAdvertiseInfo.InternalSecureTcp,
vNodeSettings.GossipAdvertiseInfo.ExternalTcp,
vNodeSettings.GossipAdvertiseInfo.ExternalSecureTcp,
vNodeSettings.GossipAdvertiseInfo.InternalHttp,
vNodeSettings.GossipAdvertiseInfo.ExternalHttp);
if (!isSingleNode)
{
// MASTER REPLICATION
var masterReplicationService = new MasterReplicationService(_mainQueue, gossipInfo.InstanceId, db, _workersHandler,
epochManager, vNodeSettings.ClusterNodeCount);
AddTask(masterReplicationService.Task);
_mainBus.Subscribe <SystemMessage.SystemStart>(masterReplicationService);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(masterReplicationService);
_mainBus.Subscribe <ReplicationMessage.ReplicaSubscriptionRequest>(masterReplicationService);
_mainBus.Subscribe <ReplicationMessage.ReplicaLogPositionAck>(masterReplicationService);
monitoringInnerBus.Subscribe <ReplicationMessage.GetReplicationStats>(masterReplicationService);
// REPLICA REPLICATION
var replicaService = new ReplicaService(_mainQueue, db, epochManager, _workersHandler, _internalAuthenticationProvider,
gossipInfo, vNodeSettings.UseSsl, vNodeSettings.SslTargetHost, vNodeSettings.SslValidateServer,
vNodeSettings.IntTcpHeartbeatTimeout, vNodeSettings.ExtTcpHeartbeatInterval);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(replicaService);
_mainBus.Subscribe <ReplicationMessage.ReconnectToMaster>(replicaService);
_mainBus.Subscribe <ReplicationMessage.SubscribeToMaster>(replicaService);
_mainBus.Subscribe <ReplicationMessage.AckLogPosition>(replicaService);
_mainBus.Subscribe <StorageMessage.PrepareAck>(replicaService);
_mainBus.Subscribe <StorageMessage.CommitAck>(replicaService);
_mainBus.Subscribe <ClientMessage.TcpForwardMessage>(replicaService);
}
// ELECTIONS
var electionsService = new ElectionsService(_mainQueue, gossipInfo, vNodeSettings.ClusterNodeCount,
db.Config.WriterCheckpoint, db.Config.ChaserCheckpoint,
epochManager, () => readIndex.LastCommitPosition, vNodeSettings.NodePriority);
electionsService.SubscribeMessages(_mainBus);
if (!isSingleNode || vNodeSettings.GossipOnSingleNode)
{
// GOSSIP
var gossip = new NodeGossipService(_mainQueue, gossipSeedSource, gossipInfo, db.Config.WriterCheckpoint,
db.Config.ChaserCheckpoint, epochManager, () => readIndex.LastCommitPosition,
vNodeSettings.NodePriority, vNodeSettings.GossipInterval, vNodeSettings.GossipAllowedTimeDifference);
_mainBus.Subscribe <SystemMessage.SystemInit>(gossip);
_mainBus.Subscribe <GossipMessage.RetrieveGossipSeedSources>(gossip);
_mainBus.Subscribe <GossipMessage.GotGossipSeedSources>(gossip);
_mainBus.Subscribe <GossipMessage.Gossip>(gossip);
_mainBus.Subscribe <GossipMessage.GossipReceived>(gossip);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(gossip);
_mainBus.Subscribe <GossipMessage.GossipSendFailed>(gossip);
_mainBus.Subscribe <SystemMessage.VNodeConnectionEstablished>(gossip);
_mainBus.Subscribe <SystemMessage.VNodeConnectionLost>(gossip);
}
AddTasks(_workersHandler.Start());
AddTask(_mainQueue.Start());
AddTask(monitoringQueue.Start());
AddTask(subscrQueue.Start());
AddTask(perSubscrQueue.Start());
if (subsystems != null)
{
foreach (var subsystem in subsystems)
{
var http = isSingleNode ? new [] { _externalHttpService } : new [] { _internalHttpService, _externalHttpService };
subsystem.Register(new StandardComponents(db, _mainQueue, _mainBus, _timerService, _timeProvider, httpSendService, http, _workersHandler));
}
}
}
private void Awake()
{
Instance = this;
}