public DesktopBridgeHost(
ILogger <DesktopBridgeHost> logger,
IHostApplicationLifetime applicationLifetime,
IBridgeServer bridgeServer,
IGeographicalAreaUpdatedConsumer geographicalAreaUpdatedConsumer)
{
_logger = logger;
_applicationLifetime = applicationLifetime;
_bridgeServer = bridgeServer;
_geographicalAreaUpdatedConsumer = geographicalAreaUpdatedConsumer;
}
public void WriteToBridgeConf(Alachisoft.NCache.Bridging.Configuration.BridgeConfiguration bridgeConfig,
TargetCacheCofiguration targtCacheConfig
)
{
char[] separater = { ',' };
bridgeConfig.TargetCacheConfigList.Remove(targtCacheConfig);
targtCacheConfig.Status = State.ToString();
bridgeConfig.TargetCacheConfigList.Add(targtCacheConfig);
// write in all bridge nodes bridge.nconnf file
bridgeConfig.DeploymentVersion++;
foreach (string bridgeIp in bridgeConfig.BridgeNodes.Split(separater).ToList())
{
_bridgeService = new NCBridgeRPCService(bridgeIp);
_bridgeServer = _bridgeService.GetBridgeServer(TimeSpan.FromSeconds(30));
_bridgeServer.RegisterBridge(bridgeConfig, true, true);
}
}
public IdentifyNetworkElementHandler(IBridgeServer bridgeServer)
{
_bridgeServer = bridgeServer;
}
public RetrieveSelectedResponseHandler(IBridgeServer bridgeServer)
{
_bridgeServer = bridgeServer;
}
public RetrieveIdentifiedNetworkElementhandler(IBridgeServer bridgeServer)
{
_bridgeServer = bridgeServer;
}
public HighlightFeaturesHandler(IBridgeServer bridgeServer)
{
_bridgeServer = bridgeServer;
}
public void AddBridgeNode()
{
try
{
_bridgeService = new NCBridgeRPCService(Server);
if (!ValidateParameters())
{
return;
}
_bridgeServer = _bridgeService.GetBridgeServer(TimeSpan.FromSeconds(30));
BridgeConfiguration bconfig = _bridgeServer.GetBridgeConfiguration(BridgeId);
ToolsUtil.VerifyBridgeConfigurations(bconfig, BridgeId);
byte[] userId = null;
byte[] paswd = null;
if (UserId != string.Empty && Password != string.Empty)
{
userId = EncryptionUtil.Encrypt(UserId);
paswd = EncryptionUtil.Encrypt(Password);
}
if (bconfig != null && bconfig.NumberOfBridgeNodes >= 2)
{
OutputProvider.WriteErrorLine("You cannot add more than 2 nodes in a Bridge");
return;
}
if (!bconfig.GetBridgeNodeList().Contains(NewBridgeNode))
{
if (bconfig.GetBridgeNodeList().Count != 0)
{
bconfig.DeploymentVersion++;
bconfig.BridgeNodes = bconfig.BridgeNodes + "," + NewBridgeNode;
_bridgeServer.RegisterBridge(bconfig, true, false);
//for registering bridge on newly added node
NCBridgeRPCService _bridgeNewService = new NCBridgeRPCService(NewBridgeNode);
IBridgeServer _bridgeNewServer = _bridgeNewService.GetBridgeServer(TimeSpan.FromSeconds(30));
_bridgeNewServer.RegisterBridge(bconfig, true, false);
OutputProvider.WriteLine(NewBridgeNode + " added to " + BridgeId);
}
else
{
bconfig.BridgeNodes = NewBridgeNode;
bconfig.BridgeActive = NewBridgeNode;
NCBridgeRPCService _bridgeNewService = new NCBridgeRPCService(NewBridgeNode);
IBridgeServer _bridgeNewServer = _bridgeNewService.GetBridgeServer(TimeSpan.FromSeconds(30));
_bridgeNewServer.RegisterBridge(bconfig, true, false);
OutputProvider.WriteLine(NewBridgeNode + " added to " + BridgeId);
}
//updating target cache config
if (bconfig.TargetCacheConfigList != null)
{
foreach (TargetCacheCofiguration targetCacheConfig in bconfig.TargetCacheConfigList)
{
try
{
if (targetCacheConfig != null)
{
foreach (string server in targetCacheConfig.Servers.Split(','))
{
NCacheRPCService NCache = new NCacheRPCService(server);;
ICacheServer cacheServer = null;
cacheServer = NCache.GetCacheServer(new TimeSpan(0, 0, 0, 30));
string cacheID = targetCacheConfig.CacheID.ToString();
CacheServerConfig serverConfig = cacheServer.GetCacheConfiguration(cacheID);
if (serverConfig.Bridge != null)
{
serverConfig.Bridge.Servers = bconfig.BridgeNodes;
}
serverConfig.ConfigVersion++;
cacheServer.ConfigureBridgeToCache(serverConfig, userId, paswd, false);
}
}
}
catch (Exception e)
{
OutputProvider.WriteErrorLine(e.Message);
return;
}
}
}
}
else
{
OutputProvider.WriteErrorLine("Error: Node already exists in bridge");
return;
}
}
catch (Exception e)
{
OutputProvider.WriteErrorLine("Error: Bridge not registered on server.\n");
OutputProvider.WriteErrorLine(e.Message);
}
}
public SelectRouteSegmentsHandler(IBridgeServer bridgeServer)
{
_bridgeServer = bridgeServer;
}
/// <summary>
/// The main entry point for the tool.
/// </summary>
public void AddBridgeCache()
{
try
{
if (!ValidateParameters())
{
return;
}
_bridgeService = new NCBridgeRPCService(BridgeServer);
if (Port == -1)
{
_bridgeService.Port = _bridgeService.UseTcp ? BridgeConfigurationManager.NCacheTcpPort : BridgeConfigurationManager.NCacheHttpPort;
}
else
{
_bridgeService.Port = Port;
}
if (!string.IsNullOrEmpty(BridgeServer))
{
_bridgeService.ServerName = BridgeServer;
}
_bridgeServer = _bridgeService.GetBridgeServer(TimeSpan.FromSeconds(30));
NCacheRPCService nService = new NCacheRPCService(CacheServer);
cacheServer = nService.GetCacheServer(new TimeSpan(0, 0, 0, 30));
//**********************************
config = cacheServer.GetCacheConfiguration(CacheName);
if (config == null)
{
OutputProvider.WriteErrorLine("Error : The cache'{0}' does not exist on server {1}:{2} .", CacheName, NCache.ServerName, NCache.Port);
return;
}
if (config.CacheType.ToLower().Equals("local-cache"))
{
OutputProvider.WriteLine("Local Cache cannot be added as a bridge cache");
return;
}
//cacheServer = GetCacheServers(config.Cluster.GetAllConfiguredNodes());
if (_bridgeServer != null)
{
try
{
OutputProvider.WriteLine("Adding Cache To Bridge '{0}' on {1}:{2}.", BridgeId, _bridgeService.ServerName, _bridgeService.Port);
Alachisoft.NCache.Bridging.Configuration.BridgeConfiguration bridgeConfig = _bridgeServer.GetBridgeConfiguration(BridgeId);
if (bridgeConfig == null)
{
OutputProvider.WriteErrorLine("No Bridge with Bridge ID '{0} exists' on Server {1}:{2}.", BridgeId, _bridgeService.ServerName, _bridgeService.Port);
return;
}
TargetCacheCofiguration targtCacheConfig = new TargetCacheCofiguration();
targtCacheConfig.CacheID = CacheName;
targtCacheConfig.CacheAlias = Alias; // set the Alias, null if name is different.
Alachisoft.NCache.Config.NewDom.CacheServerConfig serverConfig = cacheServer.GetNewConfiguration(CacheName);
string servers = String.Empty;
foreach (Address node in serverConfig.CacheDeployment.Servers.GetAllConfiguredNodes())
{
servers += node.IpAddress + ",";
}
servers = servers.Remove(servers.Length - 1);
targtCacheConfig.Servers = servers;
targtCacheConfig.IsConnected = true;
if (State.Equals(BridgeCacheStateParam.Active))
{
if (!VerifyBridgeMasterCache(BridgeId, false, bridgeConfig))
{
targtCacheConfig.IsMaster = true;
}
targtCacheConfig.Status = BridgeCacheStateParam.Active.ToString();
}
else
{
targtCacheConfig.Status = BridgeCacheStateParam.Passive.ToString();
}
ToolsUtil.VerifyBridgeConfigurations(bridgeConfig, BridgeId);
List <TargetCacheCofiguration> previouslyAddedCaches = bridgeConfig.TargetCacheConfigList;
if (previouslyAddedCaches.Count <= 1)
{
//checking validations regarding bridge
foreach (TargetCacheCofiguration pCache in previouslyAddedCaches)
{
if (pCache.CacheID.ToLower().Equals(targtCacheConfig.CacheID.ToLower()))
{
OutputProvider.WriteErrorLine("Failed to Add Cache to bridge '{0}'. Error:No Same Cache Can be Added Twice ", BridgeId);
return;
}
if (pCache.Status.Equals("passive"))
{
OutputProvider.WriteErrorLine("Failed to Add Cache to bridge '{0}'. Error:No both bridge caches can be passive ", BridgeId);
return;
}
}
}
else
{
OutputProvider.WriteErrorLine("Failed to Add Cache to bridge '{0}'. Error:No More than 2 caches can be add at a time ", BridgeId);
return;
}
//
//Adding Bridge to config.ncconf
BridgeConfig bridgeConf = new BridgeConfig();
bridgeConf.CacheAlias = Alias;
bridgeConf.Id = BridgeId;
if (config != null)
{
bridgeConf.Servers = bridgeConfig.BridgeNodes;
bridgeConf.Port = bridgeConfig.BridgePort;
bridgeConf.Status = State.ToString();
}
config.Bridge = bridgeConf;
byte[] userId = null;
byte[] paswd = null;
if (UserId != string.Empty && Password != string.Empty)
{
userId = EncryptionUtil.Encrypt(UserId);
paswd = EncryptionUtil.Encrypt(Password);
}
//writing to config.ncconf
config.ConfigVersion++;
cacheServer.ConfigureBridgeToCache(config, userId, paswd, true);
cacheServer.HotApplyBridgeReplicator(CacheName, false);
Alachisoft.NCache.Config.NewDom.CacheServerConfig nConfig = cacheServer.GetNewConfiguration(CacheName);
foreach (Address node in nConfig.CacheDeployment.Servers.GetAllConfiguredNodes())
{
NCache.ServerName = node.IpAddress.ToString();
ICacheServer server = NCache.GetCacheServer(new TimeSpan(0, 0, 0, 30));
server.ConfigureBridgeToCache(config, userId, paswd, true);
server.HotApplyBridgeReplicator(CacheName, false);
}
ConveyToRegisteredNodes();
char [] separater = { ',' };
bridgeConfig.TargetCacheConfigList.Add(targtCacheConfig);
// write in all bridge nodes bridge.nconnf file
bridgeConfig.DeploymentVersion++;
foreach (string bridgeIp in bridgeConfig.BridgeNodes.Split(separater).ToList())
{
_bridgeService = new NCBridgeRPCService(bridgeIp);
_bridgeServer = _bridgeService.GetBridgeServer(TimeSpan.FromSeconds(30));
_bridgeServer.RegisterBridge(bridgeConfig, true, true);
}
OutputProvider.WriteLine("{0} successfully added to BridgeID {1}", CacheName, BridgeId);
}
catch (SecurityException e)
{
OutputProvider.WriteErrorLine("Failed to Add Cache to bridge '{0}'. Error: {1} ", BridgeId, e.Message);
}
catch (Exception e)
{
OutputProvider.WriteErrorLine("Failed to Add Cache to bridge '{0}'. Error: {1} ", BridgeId, e.Message);
}
}
}
catch (Exception e)
{
OutputProvider.WriteErrorLine("Error: {0}", e.Message);
}
finally
{
if (_bridgeService != null)
{
_bridgeService.Dispose();
}
if (NCache != null)
{
NCache.Dispose();
}
}
}
public PanToCoordinateHandler(IBridgeServer bridgeServer)
{
_bridgeServer = bridgeServer;
}
public void AddBridge()
{
try
{
if (!ValidateParameters())
{
return;
}
_bridgeService = new NCBridgeRPCService(ActiveNode);
_bridgeService.ServerName = ActiveNode;
if (Port == -1)
{
_bridgeService.Port = _bridgeService.UseTcp ? BridgeConfigurationManager.NCacheTcpPort : BridgeConfigurationManager.NCacheHttpPort;
}
else
{
_bridgeService.Port = Port;
}
_bridgeServer = _bridgeService.GetBridgeServer(TimeSpan.FromSeconds(30));
BridgeConfiguration bridgeConfig = _bridgeServer.GetBridgeConfiguration(BridgeId);
if (bridgeConfig != null)
{
OutputProvider.WriteErrorLine("Error: Bridge with specified Bridge Id already exists.");
return;
}
else
{
bridgeConfig = new BridgeConfiguration();
bridgeConfig.ConfigID = Guid.NewGuid().ToString();
}
bridgeConfig.ID = BridgeId;
bridgeConfig.ReplicatorVirtualQueueSize = ReplicatorQueueSize;
bridgeConfig.QueueConfig.Size = MaxQueueSize;
bridgeConfig.QueueConfig.OptimizationEnabled = QueueOptimized;
bridgeConfig.BridgeActive = ActiveNode;
bridgeConfig.BridgeNodes = ActiveNode;
if (!string.IsNullOrEmpty(PassiveNode))
{
bridgeConfig.BridgeNodes = bridgeConfig.BridgeNodes + "," + PassiveNode;
//specify port for bridge
if (BridgePort != -1)
{
if (IsBridgePortAvailable(bridgeConfig, BridgePort))
{
bridgeConfig.BridgePort = BridgePort;
}
else
{
OutputProvider.WriteErrorLine("Error: Specified bridge port is not available.");
return;
}
}
else
{
bridgeConfig.BridgePort = NextAvailableBridgePort(bridgeConfig);
}
try
{
NCBridgeRPCService _bridgePassiveNodeService = new NCBridgeRPCService(PassiveNode);
IBridgeServer _bridgePassiveServer = _bridgePassiveNodeService.GetBridgeServer(TimeSpan.FromSeconds(30));
_bridgePassiveServer.RegisterBridge(bridgeConfig, false, false);
}
catch (Exception ee)
{
OutputProvider.WriteErrorLine("Error: Bridge could not be added on passive node.");
return;
}
}
else
{
//specify port for bridge
if (BridgePort != -1)
{
if (IsBridgePortAvailable(bridgeConfig, BridgePort))
{
bridgeConfig.BridgePort = BridgePort;
}
else
{
OutputProvider.WriteErrorLine("Error: Specified bridge port is not available.");
return;
}
}
else
{
bridgeConfig.BridgePort = NextAvailableBridgePort(bridgeConfig);
}
}
try
{
_bridgeServer.RegisterBridge(bridgeConfig, false, false);
OutputProvider.WriteLine("Bridge succesfully added.");
}
catch (Exception e)
{
OutputProvider.WriteErrorLine("Error: Bridge could not be added.");
return;
}
}
catch (Exception ex)
{
OutputProvider.WriteErrorLine("Error: " + ex.Message);
}
}
private bool IsBridgePortAvailable(BridgeConfiguration bconfig, int newBridgePort)
{
ArrayList nodes = bconfig.GetBridgeNodeList();
string serverName = "";
Hashtable bridgeProps = new Hashtable();
NCBridgeRPCService sw;
bool isAvailable = true;
try
{
for (int i = 0; i < nodes.Count; i++)
{
serverName = nodes[i].ToString();
sw = new NCBridgeRPCService(serverName);
IBridgeServer server = sw.GetBridgeServer(TimeSpan.FromSeconds(30));
BridgeConfiguration[] configs = server.GetAllBridgesConfiguration();
Hashtable bridgeList = new Hashtable();
if (configs != null)
{
for (int j = 0; j < configs.Length; j++)
{
bridgeList.Add(configs[j].ID.ToLower(), configs[j]);
}
}
bridgeProps = bridgeList;
if (bridgeProps != null)
{
IDictionaryEnumerator ide = bridgeProps.GetEnumerator();
while (ide.MoveNext())
{
try
{
string bridgeName = ide.Key as string;
BridgeConfiguration bridgeConfig = new BridgeConfiguration();
if (ide.Value is BridgeConfiguration)
{
bridgeConfig = (BridgeConfiguration)ide.Value;
}
if (bridgeConfig != null && bridgeConfig.BridgePort == newBridgePort)
{
isAvailable = false;
break;
}
}
catch (Exception e)
{
OutputProvider.WriteErrorLine("Error: " + e.Message);
}
}
}
}
}
catch (Exception ex)
{
OutputProvider.WriteErrorLine("Error: Failed to fetch bridge port info from " + serverName + "\n\nError: " + ex.Message);
}
return(isAvailable);
}
public void RemoveBridge()
{
try
{
if (!ValidateParameters())
{
return;
}
_bridgeService = new NCBridgeRPCService(Server);
if (Port == -1)
{
_bridgeService.Port = _bridgeService.UseTcp ? BridgeConfigurationManager.NCacheTcpPort : BridgeConfigurationManager.NCacheHttpPort;
}
else
{
_bridgeService.Port = Port;
}
_bridgeService.ServerName = Server;
_bridgeServer = _bridgeService.GetBridgeServer(TimeSpan.FromSeconds(30));
BridgeConfiguration bridgeConfig = _bridgeServer.GetBridgeConfiguration(BridgeId);
byte[] userId = null;
byte[] paswd = null;
if (UserId != string.Empty && Password != string.Empty)
{
userId = EncryptionUtil.Encrypt(UserId);
paswd = EncryptionUtil.Encrypt(Password);
}
if (bridgeConfig.GetBridgeNodeList().Count == 2)
{
_bridgeServer.UnRegisterBridge(BridgeId);
if (bridgeConfig.BridgeNodes.Contains(_bridgeServer + ","))
{
bridgeConfig.BridgeNodes = bridgeConfig.BridgeNodes.Replace(_bridgeServer + ",", "");
}
else
{
bridgeConfig.BridgeNodes = bridgeConfig.BridgeNodes.Replace("," + _bridgeServer, "");
}
bridgeConfig.BridgeActive = bridgeConfig.BridgeNodes;
NCBridgeRPCService _bridge = new NCBridgeRPCService(bridgeConfig.BridgeActive);
IBridgeServer _server = _bridge.GetBridgeServer(TimeSpan.FromSeconds(30));
_server.UnRegisterBridge(BridgeId);
}
else
{
_bridgeServer.UnRegisterBridge(BridgeId);
}
bridgeConfig.BridgeNodes = "";
//updating target cache config
if (bridgeConfig.TargetCacheConfigList != null)
{
foreach (TargetCacheCofiguration targetCacheConfig in bridgeConfig.TargetCacheConfigList)
{
try
{
if (targetCacheConfig != null)
{
foreach (string server in targetCacheConfig.Servers.Split(','))
{
NCacheRPCService NCache = new NCacheRPCService(server);;
ICacheServer cacheServer = null;
cacheServer = NCache.GetCacheServer(new TimeSpan(0, 0, 0, 30));
string cacheID = targetCacheConfig.CacheID.ToString();
CacheServerConfig serverConfig = cacheServer.GetCacheConfiguration(cacheID);
if (serverConfig.Bridge != null)
{
serverConfig.Bridge = null;
}
serverConfig.ConfigVersion++;
cacheServer.ConfigureBridgeToCache(serverConfig, userId, paswd, false);
}
}
}
catch (Exception ex)
{
OutputProvider.WriteErrorLine(ex.Message);
return;
}
}
}
OutputProvider.WriteLine("Bridge removed.");
}
catch (Exception e)
{
OutputProvider.WriteErrorLine("Bridge not registered on server.\n");
OutputProvider.WriteErrorLine("Error: " + e.Message);
return;
}
}
/// <summary>
/// The main entry point for the tool.
/// </summary>
public void SetBridgeCacheMode()
{
try
{
_bridgeService = new NCBridgeRPCService(BridgeServer);
_bridgeServer = _bridgeService.GetBridgeServer(TimeSpan.FromSeconds(30));
NCacheRPCService nService = new NCacheRPCService(CacheServer);
cacheServer = nService.GetCacheServer(new TimeSpan(0, 0, 0, 30));
if (!ValidateParameters())
{
return;
}
//**********************************
config = cacheServer.GetCacheConfiguration(CacheName);
if (config == null)
{
OutputProvider.WriteErrorLine("Error : The cache'{0}' does not exist on server {1}:{2} .", CacheName, NCache.ServerName, NCache.Port);
return;
}
if (config.CacheType.ToLower().Equals("local-cache"))
{
OutputProvider.WriteLine("Local Cache cannot be Set as a bridge cache");
return;
}
//cacheServer = GetCacheServers(config.Cluster.GetAllConfiguredNodes());
bool isNotMaster = false;
int passiveCount = 0;
TargetCacheCofiguration targtCacheConfig = null;
if (_bridgeServer != null)
{
try
{
OutputProvider.WriteLine("Setting Cache Mode To Bridge '{0}' on {1}:{2}.", BridgeId, _bridgeService.ServerName, _bridgeService.Port);
Alachisoft.NCache.Bridging.Configuration.BridgeConfiguration bridgeConfig = _bridgeServer.GetBridgeConfiguration(BridgeId);
ToolsUtil.VerifyBridgeConfigurations(bridgeConfig, BridgeId);
List <TargetCacheCofiguration> previouslyAddedCaches = bridgeConfig.TargetCacheConfigList;
if (previouslyAddedCaches.Count >= 1)
{
//checking validations regarding bridge
foreach (TargetCacheCofiguration pCache in previouslyAddedCaches)
{
if (pCache.CacheID.ToLower().Equals(CacheName.ToLower()))
{
isNotMaster = !pCache.IsMaster;
targtCacheConfig = pCache;
}
if (pCache.Status.Equals("passive"))
{
passiveCount++;
}
}
}
else
{
OutputProvider.WriteErrorLine("No Cache Exists in Bridge {0}", BridgeId);
}
if (passiveCount >= 1 && State.Equals(BridgeCacheStateParam.Passive))
{
OutputProvider.WriteErrorLine("There is already a Passive cache in Bridge", BridgeId);
return;
}
if (!isNotMaster)
{
OutputProvider.WriteErrorLine("Bridge Cache '{0}' is a master Node,please change masterNode first", CacheName);
return;
}
if (targtCacheConfig.Status.Equals(State.ToString()))
{
OutputProvider.WriteErrorLine("Bridge Cache '{0}' is already {1}", CacheName, State.ToString());
return;
}
//
//Adding Bridge to config.ncconf
BridgeConfig bridgeConf = config.Bridge;
bridgeConf.Status = State.ToString();
config.Bridge = bridgeConf;
WriteToClientConf();
WriteToBridgeConf(bridgeConfig, targtCacheConfig);
OutputProvider.WriteLine("Cache '{0}' mode set to {1}", BridgeId, State.ToString());
}
catch (SecurityException e)
{
OutputProvider.WriteErrorLine("Failed to Add Cache to bridge '{0}'. Error: {1} ", BridgeId, e.Message);
}
catch (Exception e)
{
OutputProvider.WriteErrorLine("Failed to Add Cache to bridge '{0}'. Error: {1} ", BridgeId, e.Message);
}
}
}
catch (Exception e)
{
OutputProvider.WriteErrorLine("Error: {0}", e.Message);
}
finally
{
if (_bridgeService != null)
{
_bridgeService.Dispose();
}
if (NCache != null)
{
NCache.Dispose();
}
}
}
/// <summary>
/// The main entry point for the tool.
/// </summary>
public void RemoveBridgeCache()
{
try
{
_bridgeService = new NCBridgeRPCService(BridgeServer);
_bridgeServer = _bridgeService.GetBridgeServer(TimeSpan.FromSeconds(30));
NCacheRPCService nService = new NCacheRPCService(CacheServer);
cacheServer = nService.GetCacheServer(new TimeSpan(0, 0, 0, 30));
if (!ValidateParameters())
{
return;
}
//**********************************
config = cacheServer.GetCacheConfiguration(CacheName);
if (config == null)
{
OutputProvider.WriteErrorLine("Error : The cache'{0}' does not exist on server {1}:{2} .", CacheName, NCache.ServerName, NCache.Port);
return;
}
{
//OutputProvider.WriteErrorLine("Error : The Bidge {0} is running on {1} , please stop Bridge and try again .", BridgeId, NCache.ServerName);
//return;
}
if (config.CacheType.ToLower().Equals("local-cache"))
{
OutputProvider.WriteLine("Local Cache cannot be added as a bridge cache");
return;
}
//cacheServer = GetCacheServers(config.Cluster.GetAllConfiguredNodes());
if (_bridgeServer != null)
{
try
{
OutputProvider.WriteLine("Removing Cache To Bridge '{0}' on {1}:{2}.", BridgeId, _bridgeService.ServerName, _bridgeService.Port);
Alachisoft.NCache.Bridging.Configuration.BridgeConfiguration bridgeConfig = _bridgeServer.GetBridgeConfiguration(BridgeId);
ToolsUtil.VerifyBridgeConfigurations(bridgeConfig, BridgeId);
if (bridgeConfig == null)
{
OutputProvider.WriteErrorLine("No Bridge with Bridge ID '{0} exists' on Server {1}:{2}.", BridgeId, _bridgeService.ServerName, _bridgeService.Port);
return;
}
TargetCacheCofiguration targtCacheConfig = new TargetCacheCofiguration();
targtCacheConfig.CacheID = CacheName;
targtCacheConfig.Servers = cacheServer.GetHostName();
targtCacheConfig.IsConnected = true;
{
if (!VerifyBridgeMasterCache(BridgeId, false, bridgeConfig))
{
targtCacheConfig.IsMaster = true;
}
targtCacheConfig.Status = BridgeCacheStateParam.Active.ToString();
}
List <TargetCacheCofiguration> previouslyAddedCaches = bridgeConfig.TargetCacheConfigList;
int removedCacheIndex = -1;
if (previouslyAddedCaches.Count >= 1)
{
int iteration = 0;
//checking validations regarding bridge
foreach (TargetCacheCofiguration pCache in previouslyAddedCaches)
{
//if exists than remove
if (pCache.CacheID.ToLower().Equals(CacheName.ToLower()))
{
if (pCache.CacheAlias.ToLower().Equals(Alias.ToLower()) || string.IsNullOrEmpty(Alias))
{
removedCacheIndex = iteration;
if (pCache.IsMaster)
{
OutputProvider.WriteErrorLine("Failed to Remove Cache to bridge '{0}'. Error: Master cache cannot be removed ", BridgeId);
return;
}
}
}
if (pCache.Status.Equals("passive"))
{
OutputProvider.WriteErrorLine("Failed to Remove Cache to bridge '{0}'. Error: No both bridge caches can be passive ", BridgeId);
return;
}
iteration++;
}
}
else
{
OutputProvider.WriteErrorLine("Failed to Remove Cache There is currently no Cache Added in Bridge {0} ", BridgeId);
return;
}
//
if (removedCacheIndex >= 0)
{
bridgeConfig.TargetCacheConfigList.RemoveAt(removedCacheIndex);
}
else
{
OutputProvider.WriteErrorLine("Bridge Cache Does not exists with name{0} in Bridge '{1}'", CacheName, BridgeId);
return;
}
//Adding Bridge to config.ncconf
BridgeConfig bridgeConf = config.Bridge;
config.Bridge = null;
byte[] userId = null;
byte[] paswd = null;
if (UserId != string.Empty && Password != string.Empty)
{
userId = EncryptionUtil.Encrypt(UserId);
paswd = EncryptionUtil.Encrypt(Password);
}
//writing to config.ncconf
config.ConfigVersion++;
cacheServer.ConfigureBridgeToCache(config, userId, paswd, true);
cacheServer.HotApplyBridgeReplicator(CacheName, false);
ConveyToRegisteredNodes();
char[] separater = { ',' };
// write in all bridge nodes bridge.nconnf file
bool write = false;
foreach (string bridgeIp in bridgeConfig.BridgeNodes.Split(separater).ToList())
{
try{
_bridgeService = new NCBridgeRPCService(bridgeIp);
_bridgeServer = _bridgeService.GetBridgeServer(TimeSpan.FromSeconds(30));
_bridgeServer.RegisterBridge(bridgeConfig, true, true);
write = true;
OutputProvider.WriteLine("Removed Bridge Cache {0} From Bridge {1}", CacheName, BridgeId);
}
catch (Exception e)
{
OutputProvider.WriteErrorLine("Removing Bridge Cache {0} From Bridge Server{1} Gives Error: {2}", bridgeConf, bridgeIp, e.Message);
}
}
}
catch (SecurityException e)
{
OutputProvider.WriteErrorLine("Failed to Remove Cache to bridge '{0}'. Error: {1} ", BridgeId, e.Message);
}
catch (Exception e)
{
OutputProvider.WriteErrorLine("Failed to Remove Cache to bridge '{0}'. Error: {1} ", BridgeId, e.Message);
}
}
}
catch (Exception e)
{
OutputProvider.WriteErrorLine("Error: {0}", e.Message);
}
finally
{
if (_bridgeService != null)
{
_bridgeService.Dispose();
}
if (NCache != null)
{
NCache.Dispose();
}
}
}
public GeographicalAreaUpdatedHandler(IBridgeServer bridgeServer)
{
_bridgeServer = bridgeServer;
}
/// <summary>
/// The main entry point for the tool.
/// </summary>
public void SetBridgeCacheConnection()
{
try
{
_bridgeService = new NCBridgeRPCService(BridgeServer);
_bridgeServer = _bridgeService.GetBridgeServer(TimeSpan.FromSeconds(30));
if (!ValidateParameters())
{
return;
}
//**********************************
//cacheServer = GetCacheServers(config.Cluster.GetAllConfiguredNodes());
bool isNotMaster = false;
int passiveCount = 0;
bool cacheExists = false;
TargetCacheCofiguration targtCacheConfig = null;
if (_bridgeServer != null)
{
try
{
OutputProvider.WriteLine("Setting Cache '{0}' Connection To Bridge '{1}' on {2}:{3}.", CacheName, BridgeId, _bridgeService.ServerName, _bridgeService.Port);
Alachisoft.NCache.Bridging.Configuration.BridgeConfiguration bridgeConfig = _bridgeServer.GetBridgeConfiguration(BridgeId);
ToolsUtil.VerifyBridgeConfigurations(bridgeConfig, BridgeId);
List <TargetCacheCofiguration> previouslyAddedCaches = bridgeConfig.TargetCacheConfigList;
if (previouslyAddedCaches.Count >= 1)
{
//checking validations regarding bridge
foreach (TargetCacheCofiguration pCache in previouslyAddedCaches)
{
if (pCache.CacheID.ToLower().Equals(CacheName.ToLower()))
{
cacheExists = true;
isNotMaster = !pCache.IsMaster;
targtCacheConfig = pCache;
}
if (pCache.Status.Equals("passive"))
{
passiveCount++;
}
}
}
else
{
OutputProvider.WriteErrorLine("No Cache Exists in Bridge {0}", BridgeId);
return;
}
if (previouslyAddedCaches.Count == 2 && !isNotMaster && cacheExists && Connection.ToString().ToLower().Equals("disconnect"))
{
OutputProvider.WriteErrorLine("Master Cache '{0}'cannot be disconnected,please change the master cache First", CacheName);
return;
}
if (!cacheExists)
{
OutputProvider.WriteErrorLine("No Cache Exists in Bridge {0} with CacheId {1}", BridgeId, CacheName);
}
WriteToBridgeConf(bridgeConfig, targtCacheConfig);
OutputProvider.WriteLine("Bridge Connection for Bridge {0} set to {1} Successfully!", BridgeId, Connection.ToString());
}
catch (SecurityException e)
{
OutputProvider.WriteErrorLine("Failed to Set Cache Connection Status to bridge '{0}'. Error: {1} ", BridgeId, e.Message);
}
catch (Exception e)
{
OutputProvider.WriteErrorLine("Failed to Set Cache Connection Status to bridge '{0}'. Error: {1} ", BridgeId, e.Message);
}
}
}
catch (Exception e)
{
OutputProvider.WriteErrorLine("Error: {0}", e.Message);
}
finally
{
if (_bridgeService != null)
{
_bridgeService.Dispose();
}
}
}
public void RemoveBridgeNode()
{
try
{
_bridgeService = new NCBridgeRPCService(Server);
if (!ValidateParameters())
{
return;
}
_bridgeServer = _bridgeService.GetBridgeServer(TimeSpan.FromSeconds(30));
BridgeConfiguration bridgeConfig = _bridgeServer.GetBridgeConfiguration(BridgeId);
if (!ToolsUtil.VerifyBridgeConfigurations(bridgeConfig, BridgeId))
{
OutputProvider.WriteErrorLine("Error: Configuration mismatch.");
return;
}
byte[] userId = null;
byte[] paswd = null;
if (UserId != string.Empty && Password != string.Empty)
{
userId = EncryptionUtil.Encrypt(UserId);
paswd = EncryptionUtil.Encrypt(Password);
}
if (DeleteBridgeNode == Server)
{
_bridgeServer.UnRegisterBridge(BridgeId);
}
else
{
NCBridgeRPCService _removeBridgeService = new NCBridgeRPCService(DeleteBridgeNode);
IBridgeServer _removeServer = _removeBridgeService.GetBridgeServer(TimeSpan.FromSeconds(30));
_removeServer.UnRegisterBridge(BridgeId);
}
if (bridgeConfig != null)
{
if (bridgeConfig.GetBridgeNodeList().Count == 1)
{
bridgeConfig.BridgeNodes = "";
}
else if (bridgeConfig.BridgeNodes.Contains(DeleteBridgeNode + ","))
{
bridgeConfig.BridgeNodes = bridgeConfig.BridgeNodes.Replace(DeleteBridgeNode + ",", "");
}
else
{
bridgeConfig.BridgeNodes = bridgeConfig.BridgeNodes.Replace("," + DeleteBridgeNode, "");
}
if (bridgeConfig.GetBridgeNodeList().Count == 0)
{
bridgeConfig.BridgeActive = string.Empty;
}
else
{
bridgeConfig.BridgeActive = bridgeConfig.BridgeNodes;
}
bridgeConfig.DeploymentVersion++;
if (bridgeConfig.GetBridgeNodeList().Count > 0 && !string.IsNullOrEmpty(bridgeConfig.BridgeNodes))
{
NCBridgeRPCService _bridge = new NCBridgeRPCService(bridgeConfig.BridgeActive);
IBridgeServer _server = _bridge.GetBridgeServer(TimeSpan.FromSeconds(30));
_server.RegisterBridge(bridgeConfig, true, false);
}
//updating target cache config
if (bridgeConfig.TargetCacheConfigList != null)
{
foreach (TargetCacheCofiguration targetCacheConfig in bridgeConfig.TargetCacheConfigList)
{
try
{
if (targetCacheConfig != null)
{
foreach (string server in targetCacheConfig.Servers.Split(','))
{
NCacheRPCService NCache = new NCacheRPCService(server);;
ICacheServer cacheServer = null;
cacheServer = NCache.GetCacheServer(new TimeSpan(0, 0, 0, 30));
string cacheID = targetCacheConfig.CacheID.ToString();
CacheServerConfig serverConfig = cacheServer.GetCacheConfiguration(cacheID);
if (serverConfig.Bridge != null)
{
serverConfig.Bridge.Servers = bridgeConfig.BridgeNodes;
}
serverConfig.ConfigVersion++;
cacheServer.ConfigureBridgeToCache(serverConfig, userId, paswd, false);
}
}
}
catch (Exception ex)
{
OutputProvider.WriteErrorLine(ex.Message);
return;
}
}
}
}
OutputProvider.WriteLine("Bridge node" + DeleteBridgeNode.ToString() + " removed successfully from Bridge " + BridgeId);
}
catch (Exception e)
{
OutputProvider.WriteErrorLine("Bridge not registered on server.\n");
OutputProvider.WriteErrorLine(e.Message);
return;
}
}
