public async Task Initialize()
{
_devices = new List <TurnOnOffDevice>();
_readers = new List <ReaderDevice>();
_displays = new List <DisplayDevice>();
Devices = new List <ITurnOnOffModule>();
Readers = new List <IReaderModule>();
Displays = new List <IDisplayModule>();
_conditions = new List <Condition>();
_conditionManager = new ConditionManager(_conditions, Devices);
var config = new BridgeConfiguration(StationHelper.GetDeviceID(), "com.guybrush")
{
ModelName = "Guybrush Bridge",
DeviceName = "Guybrush Smart Home",
ApplicationName = "Guybrush Station",
Vendor = "Guybrush"
};
_homeDevice = new SmarthomeAdapter(config, _conditionManager);
await AllJoynDsbServiceManager.Current.StartAsync(_homeDevice);
Status = StationStatus.Running;
}
public AccountFactory(BridgeConfiguration configuration, IServiceProvider serviceProvider)
{
_configuration = configuration;
_serviceProvider = serviceProvider;
_accounts = new Dictionary <string, IAccountController>();
}
internal static CertificateGenerator GetCertificateGeneratorInstance(BridgeConfiguration config)
{
if (s_certificateGenerator == null)
{
lock (s_certificateHelperLock)
{
if (s_certificateGenerator == null)
{
s_certificateGenerator = new CertificateGenerator()
{
CertificatePassword = config.BridgeCertificatePassword,
CrlUriBridgeHost = string.Format("http://{0}:{1}", config.BridgeHost, config.BridgePort),
CrlUriRelativePath = s_crlUriRelativePath,
ValidityPeriod = config.BridgeCertificateValidityPeriod
};
// Upon creation, we want to immediately get the authority certificate and install it
// as it means we are about to run a test requiring certs
CertificateManager.InstallCertificateToRootStore(s_certificateGenerator.AuthorityCertificate.Certificate);
}
}
}
return(s_certificateGenerator);
}
internal static string EnsureSslPortCertificateInstalled(BridgeConfiguration configuration)
{
// Ensure the https certificate is installed before this endpoint resource is used
X509Certificate2 cert = CertificateManager.CreateAndInstallLocalMachineCertificates(GetCertificateGeneratorInstance(configuration));
// Ensure http.sys has been told to use this certificate on the https port
CertificateManager.InstallSSLPortCertificate(cert.Thumbprint, configuration.BridgeHttpsPort);
return(cert.Thumbprint);
}
public SmarthomeAdapter(BridgeConfiguration configuration, ConditionManager conditionMgr) : base(configuration)
{
_conditionManager = conditionMgr;
_abo = new AdapterBusObject("Guybrush");
AdapterInterface conditionInterface = new AdapterInterface("com.guybrush.station.conditions");
var addConInputParams = new List <AdapterValue>();
addConInputParams.Add(new AdapterValue("SourceDeviceType", -1));
addConInputParams.Add(new AdapterValue("SourceDevice", ""));
addConInputParams.Add(new AdapterValue("TargetDevice", ""));
addConInputParams.Add(new AdapterValue("RequiredValue", -1));
addConInputParams.Add(new AdapterValue("ConditionType", -1));
addConInputParams.Add(new AdapterValue("TargetValue", -1));
var addConOutParams = new List <AdapterValue>();
addConOutParams.Add(new AdapterValue("Response", ""));
AdapterMethod addCondAttr = new AdapterMethod("AddCondition", "Calling this method will add new condition.", AddCondition, addConInputParams, addConOutParams);
conditionInterface.Methods.Add(addCondAttr);
var getCondOutParams = new List <AdapterValue>();
getCondOutParams.Add(new AdapterValue("SourceDeviceType", ""));
getCondOutParams.Add(new AdapterValue("SourceDevice", ""));
getCondOutParams.Add(new AdapterValue("TargetDevice", ""));
getCondOutParams.Add(new AdapterValue("RequiredValue", ""));
getCondOutParams.Add(new AdapterValue("ConditionType", ""));
getCondOutParams.Add(new AdapterValue("TargetValue", ""));
AdapterMethod getCondAttr = new AdapterMethod("GetConditions", "Calling this method returns list of conditions", GetConditions, null, getCondOutParams);
conditionInterface.Methods.Add(getCondAttr);
var removeCondInputParams = new List <AdapterValue>();
removeCondInputParams.Add(new AdapterValue("SourceDevice", ""));
removeCondInputParams.Add(new AdapterValue("TargetDevice", ""));
var removeConOutParams = new List <AdapterValue>();
removeConOutParams.Add(new AdapterValue("Response", ""));
AdapterMethod removeCondAttr = new AdapterMethod("RemoveCondition", "Calling this method will remove a condition", RemoveCondition, removeCondInputParams, removeConOutParams);
conditionInterface.Methods.Add(removeCondAttr);
_abo.Interfaces.Add(conditionInterface);
BusObjects.Add(_abo);
}
internal static string EnsureHttpsCertificateInstalled(BridgeConfiguration configuration)
{
// Ensure the https certificate is installed before this endpoint resource is used
string certThumbPrint = CertificateManager.InstallMyCertificate(configuration,
configuration.BridgeHttpsCertificate);
// Ensure http.sys has been told to use this certificate on the https port
CertificateManager.InstallSSLPortCertificate(certThumbPrint, configuration.BridgeHttpsPort);
return(certThumbPrint);
}
private void _processContentConfig(BridgeContentConfig contentConfig, Stream stream)
{
var serializer = new SerializerBuilder().ConfigureDefaultValuesHandling(DefaultValuesHandling.OmitNull).Build();
var watch = new Stopwatch();
string serializationFolder = BridgeConfiguration.GetConfig().SerializationFolder;
_clearTempFolder();
watch.Start();
//have this driven by config
var serializationPath = $"{serializationFolder}/content/{contentConfig.Name}";
var tempGUID = DateTime.Now.Ticks.ToString();
var tempSerializationPath = $"{serializationFolder}/temp/{tempGUID}/{contentConfig.Name}";
var pageTypes = contentConfig.GetPageTypes();
var fieldsToIgnore = contentConfig.GetIgnoreFields();
var path = contentConfig.Query;
//TODO: Query to see if page types exist, if DOESNT, display that...
MultiDocumentQuery docs = DocumentHelper.GetDocuments().Path(path).Types(pageTypes.ToArray()).AllCultures().FilterDuplicates();
var treeNodes = docs.ToList <TreeNode>();
foreach (var treeNode in treeNodes)
{
watch.Reset();
watch.Start();
var mappedItem = treeNode.Adapt <BridgeTreeNode>();
mappedItem.FieldValues = new Dictionary <string, object>();
foreach (string columnName in treeNode.ColumnNames)
{
if (!fieldsToIgnore.Contains(columnName))
{
var columnValue = treeNode.GetValue(columnName);
if (columnValue != null)
{
mappedItem.FieldValues.Add(columnName, columnValue);
}
}
}
mappedItem.ParentNodeGUID = treeNode?.Parent?.NodeGUID;
var stringBuilder = new StringBuilder();
var res = serializer.Serialize(mappedItem);
stringBuilder.AppendLine(res);
var pathToWriteTo = $"{tempSerializationPath}/{mappedItem.NodeAliasPath}#{mappedItem.DocumentCulture}.yaml";
var concretePath = this.GetRootPath(pathToWriteTo);
FileInfo file = new FileInfo(concretePath);
file.Directory.Create(); // If the directory already exists, this method does nothing.
File.WriteAllText(concretePath, res);
}
watch.Stop();
_outputToStream(stream, $"Generating temp {contentConfig.Name} - {watch.ElapsedMilliseconds}ms");
_processDifferences(stream, watch, serializationPath, tempSerializationPath);
}
// Returns 'true' if the BridgeConfiguration describes a Bridge that
// would run locally.
private static bool IsBridgeHostLocal(BridgeConfiguration configuration)
{
if (String.Equals("localhost", configuration.BridgeHost, StringComparison.OrdinalIgnoreCase))
{
return(true);
}
if (String.Equals(Environment.MachineName, configuration.BridgeHost, StringComparison.OrdinalIgnoreCase))
{
return(true);
}
return(false);
}
private void _processContentConfig(BridgeContentConfig contentConfig, Stream stream)
{
var serializer = new SerializerBuilder().ConfigureDefaultValuesHandling(DefaultValuesHandling.OmitNull).Build();
var watch = new Stopwatch();
string serializationFolder = BridgeConfiguration.GetConfig().SerializationFolder;
//have this driven by config
var serializationPath = $"{serializationFolder}/content/{contentConfig.Name}";
var pageTypes = contentConfig.GetPageTypes();
var fieldsToIgnore = contentConfig.GetIgnoreFields();
var path = contentConfig.Query;
MultiDocumentQuery docs = DocumentHelper.GetDocuments().Path(path).Types(pageTypes.ToArray()).AllCultures().FilterDuplicates();
var treeNodes = docs.ToList <TreeNode>();
foreach (var treeNode in treeNodes)
{
watch.Reset();
watch.Start();
var mappedItem = treeNode.Adapt <BridgeTreeNode>();
mappedItem.FieldValues = new Dictionary <string, object>();
foreach (string columnName in treeNode.ColumnNames)
{
if (!fieldsToIgnore.Contains(columnName))
{
var columnValue = treeNode.GetValue(columnName);
if (columnValue != null)
{
mappedItem.FieldValues.Add(columnName, columnValue);
}
}
}
mappedItem.ParentNodeGUID = treeNode?.Parent?.NodeGUID;
var stringBuilder = new StringBuilder();
var res = serializer.Serialize(mappedItem);
stringBuilder.AppendLine(res);
var pathToWriteTo = $"{serializationPath}/{mappedItem.NodeAliasPath}#{mappedItem.DocumentCulture}.yaml";
var concretePath = this.GetRootPath(pathToWriteTo);
FileInfo file = new FileInfo(concretePath);
file.Directory.Create(); // If the directory already exists, this method does nothing.
File.WriteAllText(concretePath, res);
watch.Stop();
byte[] bytes = Encoding.UTF8.GetBytes($"Serialized {contentConfig.Name}: {mappedItem.NodeAliasPath}#{mappedItem.DocumentCulture}.yaml ({mappedItem.NodeGUID}) - {watch.ElapsedMilliseconds}ms");
stream.Write(bytes, 0, bytes.Length);
stream.WriteByte(10);
stream.Flush();
}
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("Options are:")
.AppendLine(String.Format(" -allowRemote = {0}", AllowRemote))
.AppendLine(String.Format(" -remoteAddresses = {0}", RemoteAddresses))
.AppendLine(String.Format(" -ping = {0}", Ping))
.AppendLine(String.Format(" -stop = {0}", Stop))
.AppendLine(String.Format(" -stopIfLocal = {0}", StopIfLocal))
.AppendLine(String.Format(" -reset = {0}", Reset))
.AppendLine(String.Format("BridgeConfiguration is:{0}{1}",
Environment.NewLine, BridgeConfiguration.ToString()));
return(sb.ToString());
}
public HttpResponseMessage Get(HttpRequestMessage request)
{
Dictionary <string, string> dictionary = BridgeConfiguration.ToDictionary();
string configResponse = JsonSerializer.SerializeDictionary(dictionary);
Trace.WriteLine(String.Format("{0:T} - GET config returning raw content:{1}{2}",
DateTime.Now, Environment.NewLine, configResponse),
typeof(ConfigController).Name);
// Directly return a json string to avoid use of MediaTypeFormatters
HttpResponseMessage response = request.CreateResponse(HttpStatusCode.OK);
response.Content = new StringContent(configResponse);
response.Content.Headers.ContentType = new MediaTypeHeaderValue(JsonSerializer.JsonMediaType);
return(response);
}
static void DumpConfig(BridgeConfiguration config, IPEndPoint presenceServiceEndPoint)
{
Trace.WriteLine(":: Settings ::");
Trace.WriteLine("");
Trace.WriteLine("Bridge endpoint (Internal): " + config.InternalServiceBinding.EndPoint);
Trace.WriteLine("Bridge endpoint (External): " + config.ExternalServiceBinding.EndPoint);
Trace.WriteLine("Presence multicast endpoint: " + config.PresenceBinding.MulticastEndPoint);
Trace.WriteLine("Presence endpoint: " + presenceServiceEndPoint);
Trace.WriteLine("");
Trace.WriteLine(":: Target bridges ::");
Trace.WriteLine("");
foreach (Target target in config.Targets)
{
Trace.WriteLine(target.EndPoint);
}
Trace.WriteLine("");
}
public static IScriptHost GetScriptHost()
{
var console = new CakeConsole();
ICakeLog log = new CakeBuildLog(console);
IFileSystem fileSystem = new FileSystem();
ICakeDataService data = new BridgeDataService();
ICakeEnvironment environment = new CakeEnvironment(
new CakePlatform(),
new CakeRuntime(),
log
);
IGlobber globber = new Globber(fileSystem, environment);
ICakeArguments arguments = new BridgeArguments();
ICakeConfiguration configuration = new BridgeConfiguration();
IToolLocator tools = new ToolLocator(
environment,
new ToolRepository(environment),
new ToolResolutionStrategy(
fileSystem,
environment,
globber,
configuration
)
);
ICakeContext context = new CakeContext(
fileSystem,
environment,
globber,
log,
arguments,
new ProcessRunner(fileSystem, environment, log, tools, configuration),
new WindowsRegistry(),
tools,
data,
configuration
);
return(new BridgeScriptHost(
new CakeEngine(data, log),
context,
new DefaultExecutionStrategy(log),
new CakeReportPrinter(console, context),
arguments
));
}
public Home()
{
this.RequiresAuthentication(HttpContext.Current);
Get("/index", parameters => {
var bridgeCoreConfigs = BridgeConfiguration.GetConfig().CoreConfigs;
var bridgeContentConfigs = BridgeConfiguration.GetConfig().ContentConfigs;
var currentRequest = Request.Url;
currentRequest.Path = (ConfigurationManager.AppSettings["BridgeBaseUrl"] ?? "/Admin/BridgeUI").ToString();
var model = new { coreConfigs = bridgeCoreConfigs, contentConfigs = bridgeContentConfigs, urlBase = currentRequest.ToString() };
return(View["Index", model]);
});
Get("/about", parameters => "Hello from Bridge -|--|-");
//Get("/{all*}", parameters =>
//{
// //If you are having serious problems hitting anything, uncomment this
// var test = Request;
// return "catchall";
//});
}
protected override void OnStart(string[] args)
{
var config = BridgeConfiguration.GetConfig();
var presenceServiceEndPoint = new IPEndPoint(config.InternalServiceBinding.EndPoint.Address, config.PresenceBinding.ServicePort);
var multicastReceiveEndPoint = new IPEndPoint(config.InternalServiceBinding.EndPoint.Address, config.PresenceBinding.CallbackPort);
DumpConfig(config, presenceServiceEndPoint);
bridge = new SquiggleBridge(config.InternalServiceBinding.EndPoint,
config.ExternalServiceBinding.EndPoint,
config.PresenceBinding.MulticastEndPoint,
multicastReceiveEndPoint,
presenceServiceEndPoint);
foreach (Target target in config.Targets)
{
bridge.AddTarget(target.EndPoint);
}
bridge.Start();
}
private void _clearTempFolder()
{
try
{
//just trying to clean up some temp stuff from prev diffs
string serializationFolder = BridgeConfiguration.GetConfig().SerializationFolder;
var tempRoot = this.GetRootPath($"{serializationFolder}/temp");
DirectoryInfo di = new DirectoryInfo(tempRoot);
foreach (FileInfo file in di.EnumerateFiles())
{
file.Delete();
}
foreach (DirectoryInfo dir in di.EnumerateDirectories())
{
dir.Delete(true);
}
}
catch (Exception ex)
{
//keep moving
}
}
private void _processCoreConfig(BridgeCoreConfig coreConfig, Stream stream)
{
string serializationFolder = BridgeConfiguration.GetConfig().SerializationFolder;
var deserializer = new DeserializerBuilder().Build();
TreeProvider tree = new TreeProvider(MembershipContext.AuthenticatedUser);
var watch = new Stopwatch();
//have this driven by config
var serializationPath = $"{serializationFolder}/core/{coreConfig.Name}";
var classTypes = coreConfig.GetClassTypes();
var ignoreFields = coreConfig.GetIgnoreFields();
var allAllowedChildInfos = new List <AllowedChildClassInfo>();
int retryCount = 3;
_processClasses(retryCount, allAllowedChildInfos, coreConfig.Name, stream, deserializer, watch, serializationPath, classTypes, ignoreFields);
//at this point we should have all children, lets post process these
foreach (var allowedChildClass in allAllowedChildInfos)
{
AllowedChildClassInfoProvider.SetAllowedChildClassInfo(allowedChildClass);
}
}
private async void CheckBridgeStatus()
{
status.Text = "Starting up bridge...";
try
{
var config = new BridgeConfiguration(GetDeviceID(), "com.dotMorten.TestApp")
{
// The following are optional. If not set will be pulled from the package information and system information
ModelName = "AllJoyn Mock DSB",
DeviceName = "AllJoyn Simulator",
ApplicationName = "AllJoyn Device Simulator",
Vendor = "MockDevices Inc"
};
await AllJoynDsbServiceManager.Current.StartAsync(config);
status.Text = ""; // Bridge Successfully Initialized
addDeviceBox.IsEnabled = true;
}
catch (System.Exception ex)
{
status.Text = "Bridge failed to initialize:\n" + ex.Message;
return;
}
LoadDevices();
}
public BridgeComponent(BridgeConfiguration <TLeft, TRight> config)
{
this.config = config;
}
public static IScenarioWithEndpointBehavior <TContext> With <TContext, TLeft, TRight>(this IScenarioWithEndpointBehavior <TContext> scenario, BridgeConfiguration <TLeft, TRight> config)
where TContext : ScenarioContext
where TLeft : TransportDefinition, new()
where TRight : TransportDefinition, new()
{
return(scenario.WithComponent(new BridgeComponent <TLeft, TRight>(config)));
}
public BridgeComponent(Func <BridgeConfiguration <TLeft, TRight> > config)
{
this.config = config();
}
public Bridge(BridgeConfiguration configuration, GatewayFactory factory)
{
_configuration = configuration;
_factory = factory;
}
private bool VerifyBridgeMasterCache(string bridgeID, bool findConnectedMaster, BridgeConfiguration bridgeConfig)
{
bool isBridgeCacheMaster = false;
if (bridgeConfig != null && bridgeConfig.TargetCacheConfigList != null)
{
foreach (TargetCacheCofiguration targetCacheConfig in bridgeConfig.TargetCacheConfigList)
{
if (targetCacheConfig != null && targetCacheConfig.IsMaster)
{
if (findConnectedMaster && targetCacheConfig.IsConnected || !findConnectedMaster)
{
isBridgeCacheMaster = true;
break;
}
}
}
}
return(isBridgeCacheMaster);
}
private void _processCoreConfig(BridgeCoreConfig coreConfig, Stream stream)
{
var serializer = new SerializerBuilder().ConfigureDefaultValuesHandling(DefaultValuesHandling.OmitNull).Build();
string serializationFolder = BridgeConfiguration.GetConfig().SerializationFolder;
var watch = new Stopwatch();
_clearTempFolder();
watch.Start();
//have this driven by config
var serializationPath = $"{serializationFolder}/core/{coreConfig.Name}";
var tempGUID = DateTime.Now.Ticks.ToString();
var tempSerializationPath = $"{serializationFolder}/temp/{tempGUID}/{coreConfig.Name}";
var classTypes = coreConfig.GetClassTypes();
var fieldsToIgnore = coreConfig.GetIgnoreFields();
ProviderHelper.ClearHashtables("cms.class", false);
foreach (var classType in classTypes)
{
var dci = DataClassInfoProvider.GetDataClassInfo(classType);
if (dci != null)
{
var mappedItem = dci.Adapt <BridgeClassInfo>();
mappedItem.FieldValues = new Dictionary <string, object>();
foreach (string columnName in dci.ColumnNames)
{
if (!fieldsToIgnore.Contains(columnName))
{
var columnValue = dci.GetValue(columnName);
mappedItem.FieldValues.Add(columnName, columnValue);
}
}
var assignedSites = new List <Guid>();
foreach (SiteInfo assignedSite in dci.AssignedSites)
{
assignedSites.Add(assignedSite.SiteGUID);
}
mappedItem.AssignedSites = assignedSites;
var allowedChildClasses = AllowedChildClassInfoProvider.GetAllowedChildClasses().Where("ParentClassID", QueryOperator.Equals, dci["ClassID"].ToString()).Column("ChildClassID").ToList();
var allowedChildrenTypes = new List <string>();
foreach (AllowedChildClassInfo allowedChildClass in allowedChildClasses)
{
var className = new ObjectQuery("cms.class").Where("ClassID", QueryOperator.Equals, allowedChildClass.ChildClassID).Column("ClassName").FirstOrDefault()["ClassName"].ToString();
allowedChildrenTypes.Add(className);
}
mappedItem.AllowedChildTypes = allowedChildrenTypes;
var classQueries = QueryInfoProvider.GetQueries().Where("ClassID", QueryOperator.Equals, dci.ClassID).ToList();
var queries = new Dictionary <string, BridgeClassQuery>();
foreach (var classQuery in classQueries)
{
var bcq = classQuery.Adapt <BridgeClassQuery>();
queries.Add(classQuery.QueryName, bcq);
}
mappedItem.Queries = queries;
var stringBuilder = new StringBuilder();
var res = serializer.Serialize(mappedItem);
stringBuilder.AppendLine(res);
var pathToMatching = $"{tempSerializationPath}/{mappedItem.ClassName.ToLower()}.yaml";
var tempPath = this.GetRootPath(pathToMatching);
FileInfo file = new FileInfo(tempPath);
file.Directory.Create(); // If the directory already exists, this method does nothing.
File.WriteAllText(tempPath, res);
}
}
watch.Stop();
_outputToStream(stream, $"Generating temp {coreConfig.Name} - {watch.ElapsedMilliseconds}ms");
_processDifferences(stream, watch, serializationPath, tempSerializationPath);
}
public Diff()
{
this.RequiresAuthentication(HttpContext.Current);
Get("/diffcore/{id}", parameters =>
{
var response = new Response();
response.ContentType = "text/plain";
response.Contents = stream =>
{
var bridgeCoreConfigs = BridgeConfiguration.GetConfig().CoreConfigs;
string configName = parameters.id;
foreach (BridgeCoreConfig coreConfig in bridgeCoreConfigs)
{
if (configName.ToLower() == coreConfig.Name.ToLower())
{
_processCoreConfig(coreConfig, stream);
}
}
};
return(response);
});
Get("/diffcontent/{id}", parameters =>
{
var response = new Response();
response.ContentType = "text/plain";
response.Contents = stream =>
{
var bridgeContentConfigs = BridgeConfiguration.GetConfig().ContentConfigs;
string configName = parameters.id;
foreach (BridgeContentConfig contentConfig in bridgeContentConfigs)
{
if (configName.ToLower() == contentConfig.Name.ToLower())
{
_processContentConfig(contentConfig, stream);
}
}
};
return(response);
});
Get("/viewdiff", parameters =>
{
var response = new Response();
response.ContentType = "text/plain";
response.Contents = stream =>
{
var bridgeContentConfigs = BridgeConfiguration.GetConfig().ContentConfigs;
string origFolder = Request.Query["origFolder"];
string tempFolder = Request.Query["tempFolder"];
string file = Request.Query["file"];
var origPath = this.GetRootPath($"{origFolder}/{file}");
var origYamlFileContents = File.ReadAllText(origPath);
var tempPath = this.GetRootPath($"{tempFolder}/{file}");
var tempFileContents = File.ReadAllText(tempPath);
var diffBuilder = new InlineDiffBuilder(new Differ());
var diff = diffBuilder.BuildDiffModel(origYamlFileContents, tempFileContents);
foreach (var line in diff.Lines)
{
string linePrefix = "";
string lineSuffix = "";
switch (line.Type)
{
case ChangeType.Inserted:
linePrefix = "K <strong>";
lineSuffix = "</strong>";
break;
case ChangeType.Deleted:
linePrefix = "F <em>";
lineSuffix = "</em>";
break;
default:
linePrefix = " ";
lineSuffix = "";
break;
}
_outputToStream(stream, $"{linePrefix}{line.Text}{lineSuffix}");
}
};
return(response);
});
}
private bool Parse(string[] args)
{
// Build a dictionary of all command line arguments.
// This allows us to initialize BridgeConfiguration from it.
// Precedence of values in the BridgeConfiguration is this:
// - Lowest precedence is the BridgeConfiguration ctor defaults
// - Next precedence is any value found in a specified configuration file
// - Next precedence is environment variables
// - Highest precedence is a BridgeConfiguration value explicitly set on the command line
Dictionary <string, string> argumentDictionary = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
foreach (string arg in args)
{
if (!arg.StartsWith("/") && !arg.StartsWith("-"))
{
return(false);
}
// Cannot use split because some argument values could contain colons
int index = arg.IndexOf(':');
string argName = (index < 0) ? arg.Substring(1) : arg.Substring(1, index - 1);
string argValue = (index < 0) ? String.Empty : arg.Substring(index + 1);
if (String.Equals(argName, "?", StringComparison.OrdinalIgnoreCase))
{
return(false);
}
argumentDictionary[argName] = argValue;
}
BridgeConfiguration = new BridgeConfiguration();
// If the user specified a configuration file, deserialize it as json
// and treat each name-value pair as if it had been on the command line.
// But options explicitly on the command line take precedence over these file options.
string argumentValue;
if (argumentDictionary.TryGetValue("bridgeConfig", out argumentValue))
{
if (!File.Exists(argumentValue))
{
Console.WriteLine("The configuration file '{0}' does not exist.");
return(false);
}
// Read the configuration file as json and deserialize it
string configurationAsJson = File.ReadAllText(argumentValue);
Dictionary <string, string> deserializedConfig = null;
try
{
deserializedConfig = JsonSerializer.DeserializeDictionary(configurationAsJson);
}
catch (Exception ex)
{
// Catch all exceptions because any will cause
// this application to terminate.
Console.WriteLine("Error deserializing {0} : {1}",
argumentValue, ex.Message);
return(false);
}
// Every name/value pair in the config file not explicitly set on the command line
// is treated as if it had been on the command line.
foreach (var pair in deserializedConfig)
{
if (!argumentDictionary.ContainsKey(pair.Key))
{
argumentDictionary[pair.Key] = pair.Value;
}
}
}
// For every property in the BridgeConfiguration that has not been explicitly
// specified on the command line or via the config file, check if there is an
// Environment variable set for it. If so, use it as if it had been on the command line.
foreach (string key in BridgeConfiguration.ToDictionary().Keys)
{
// If the property is explicitly on the command line, it has highest precedence
if (!argumentDictionary.ContainsKey(key))
{
// But if it is not explicitly on the command line but
// an environment variable exists for it, it has higher precedence
// than defaults or the config file.
string environmentVariable = Environment.GetEnvironmentVariable(key);
if (!String.IsNullOrWhiteSpace(environmentVariable))
{
argumentDictionary[key] = environmentVariable;
}
}
}
// Finally, apply all our command line arguments to the BridgeConfiguration,
// overwriting any values that were the default or came from the optional config file
BridgeConfiguration = new BridgeConfiguration(BridgeConfiguration, argumentDictionary);
// Finish parsing the command line arguments that are not part of BridgeConfiguration
if (argumentDictionary.ContainsKey("allowRemote"))
{
AllowRemote = true;
}
if (argumentDictionary.ContainsKey("ping"))
{
Ping = true;
}
if (argumentDictionary.ContainsKey("stop"))
{
Stop = true;
}
if (argumentDictionary.ContainsKey("stopiflocal"))
{
StopIfLocal = true;
}
string remoteAddresses;
if (argumentDictionary.TryGetValue("remoteAddresses", out remoteAddresses))
{
RemoteAddresses = remoteAddresses;
}
if (argumentDictionary.ContainsKey("reset"))
{
Reset = true;
}
return(true);
}
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);
}
}
internal static X509Certificate2 EnsureRevokedCertificateInstalled(BridgeConfiguration configuration, CertificateCreationSettings certificateCreationSettings, string resourceAddress)
{
return(CertificateManager.CreateAndInstallNonDefaultMachineCertificates(GetCertificateGeneratorInstance(configuration), certificateCreationSettings, resourceAddress));
}
internal static string EnsureSslPortCertificateInstalled(BridgeConfiguration configuration)
{
return(EnsureSslPortCertificateInstalled(configuration, configuration.BridgeHttpsPort));
}
public HttpResponseMessage POST(HttpRequestMessage request)
{
// A configuration change can have wide impact, so we don't allow concurrent use
lock (BridgeLock)
{
try
{
// Handle deserialization explicitly to bypass MediaTypeFormatter use
string nameValuePairs = request.Content.ReadAsStringAsync().GetAwaiter().GetResult();
Dictionary <string, string> configInfo = JsonSerializer.DeserializeDictionary(nameValuePairs);
Trace.WriteLine(String.Format("{0:T} -- POST config received raw content:{1}{2}",
DateTime.Now, Environment.NewLine, nameValuePairs),
typeof(ConfigController).Name);
// Create a new configuration combining the existing one with any provided properties.
BridgeConfiguration newConfiguration = new BridgeConfiguration(BridgeConfiguration, configInfo);
Trace.WriteLine(String.Format("{0:T} -- applying new config:{0}{1}",
DateTime.Now, Environment.NewLine, newConfiguration),
typeof(ConfigController).Name);
// Take the new configuration and notify listeners of the change.
BridgeConfiguration oldConfiguration = BridgeConfiguration;
BridgeConfiguration = newConfiguration;
// Notify of change of resource folder
bool resourceFolderChanged = !String.Equals(oldConfiguration.BridgeResourceFolder, newConfiguration.BridgeResourceFolder, StringComparison.OrdinalIgnoreCase);
if (ResourceFolderChanged != null && resourceFolderChanged)
{
ResourceFolderChanged(this, new ChangedEventArgs <string>(
oldConfiguration.BridgeResourceFolder,
newConfiguration.BridgeResourceFolder));
}
// Notify of change of the idle timeout
if (IdleTimeoutChanged != null &&
oldConfiguration.BridgeMaxIdleTimeSpan != newConfiguration.BridgeMaxIdleTimeSpan)
{
IdleTimeoutChanged(this, new ChangedEventArgs <TimeSpan>(
oldConfiguration.BridgeMaxIdleTimeSpan,
newConfiguration.BridgeMaxIdleTimeSpan));
}
// When the resource folder changes, the response is an array of
// resource types. Any other changes returns an empty string.
string configResponse = resourceFolderChanged
? PrepareConfigResponse(TypeCache.Cache[CurrentAppDomainName])
: String.Empty;
Trace.WriteLine(String.Format("{0:T} - POST config returning raw content:{1}{2}",
DateTime.Now, Environment.NewLine, configResponse),
typeof(ConfigController).Name);
// Directly return a json string to avoid use of MediaTypeFormatters
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK);
response.Content = new StringContent(configResponse);
response.Content.Headers.ContentType = new MediaTypeHeaderValue(JsonSerializer.JsonMediaType);
return(response);
}
catch (Exception ex)
{
var exceptionResponse = ex.Message;
Trace.WriteLine(String.Format("{0:T} - POST config exception:{1}{2}",
DateTime.Now, Environment.NewLine, ex),
typeof(ConfigController).Name);
return(Request.CreateResponse(HttpStatusCode.BadRequest, exceptionResponse));
}
}
}
internal static string EnsureNonDefaultCertificateInstalled(BridgeConfiguration configuration, CertificateCreationSettings certificateCreationSettings, string resourceAddress)
{
X509Certificate2 cert = CertificateManager.CreateAndInstallNonDefaultMachineCertificates(GetCertificateGeneratorInstance(configuration), certificateCreationSettings, resourceAddress);
return(cert.Thumbprint);
}
