public static bool CacheExists(IDictionary <string, ConfigurationVersion> configs)
{
if (configs != null && configs.Count > 0)
{
int failedCount = 0;
ConfigurationVersion latestConfig = null;
foreach (KeyValuePair <string, ConfigurationVersion> config in configs)
{
latestConfig = config.Value as ConfigurationVersion;
if (string.IsNullOrEmpty(latestConfig.ConfigID))
{
failedCount++;
}
}
if (failedCount < configs.Count)
{
return(true);
}
else
{
return(false);
}
}
return(false);
}
public MetaFrame(EncodingOptions options)
{
Name = new String();
Description = new LocalizedText();
ConfigurationVersion = new ConfigurationVersion();
DiscoveryResponseHeader = new DiscoveryResponseHeader
{
ResponseType = 2
};
}
public static IConfigConverter CreateConverter(ConfigurationVersion Ver)
{
switch (Ver)
{
case ConfigurationVersion.Ver22:
return(new ConfigConverter_22());
default:
return(null);
}
}
public static string ToString(ConfigurationVersion Ver)
{
switch (Ver)
{
case ConfigurationVersion.Ver22:
return("22");
default:
return("21");
}
}
public static bool VerifyClusterConfigurations(Alachisoft.NCache.Config.NewDom.CacheServerConfig serverConfig
, string cacheName)
{
if (serverConfig == null)
{
throw new Exception("Specified cache is not registered on the given server");
}
double configVersion = -1;
double deploymentVersion = -1;
string configId = "dummyconfig";
NCacheRPCService NCache = new NCacheRPCService("");
if (serverConfig.CacheSettings.CacheType == "clustered-cache")
{
foreach (Address node in serverConfig.CacheDeployment.Servers.GetAllConfiguredNodes())
{
NCache.ServerName = node.IpAddress.ToString();
ICacheServer cacheServer = NCache.GetCacheServer(new TimeSpan(0, 0, 0, 30));
ConfigurationVersion config = cacheServer.GetConfigurationVersion(cacheName);
if (configId.Equals(configId))
{
configId = config.ConfigID;
}
else if (!configId.Equals(config.ConfigID, StringComparison.InvariantCultureIgnoreCase))
{
throw new VersionException("same name cache is already registered on node : " + node.IpAddress, 0);
}
if (configVersion == -1)
{
configVersion = config.ConfigVersion;
}
else if (configVersion != config.ConfigVersion)
{
throw new VersionException("There is a configuration mismatch for caches : " + cacheName, 0);
}
if (deploymentVersion == -1)
{
deploymentVersion = config.DeploymentVersion;
}
else if (deploymentVersion != config.DeploymentVersion)
{
throw new Exception("Deployment version is not same on all nodes");
}
cacheServer.Dispose();
}
}
return(true);
}
internal void UpdateDataSet(DomainModelWrapper domainMode, SemanticsDataIndexWrapper selectedIndex, bool newVersion)
{
InformationModelURI = domainMode.URI.ToString();
Id = domainMode.UniqueName;
ConfigurationGuid = Guid.NewGuid();
if (newVersion)
{
ConfigurationVersion.IncrementMajorVersion();
}
DataSet = CreateDataSet(selectedIndex);
DefaultDataSetWriterId = Convert.ToUInt16(domainMode.SemanticsDataCollection.IndexOf(selectedIndex));
MaxBufferTime = -1;
RepositoryGroup = String.Empty;
SymbolicName = selectedIndex.SymbolicName;
}
/// <summary>
/// TfeClient
/// </summary>
/// <param name="config"></param>
public TfeClient(TfeConfig config)
{
this.client = config.HttpClient;
Apply = new Apply(client);
Organization = new Organization(client);
SshKey = new SshKey(client);
Run = new Run(client);
Workspace = new Workspace(client);
WorkspaceVariable = new WorkspaceVariable(client);
OAuthClient = new OAuthClient(client);
OAuthToken = new OAuthToken(client);
StateVersion = new StateVersion(client);
StateVersionOutput = new StateVersionOutput(client);
TeamWorkspace = new TeamWorkspace(client);
Plan = new Plan(client);
ConfigurationVersion = new ConfigurationVersion(client);
}
public static double GetLatestConfigurationversion(IDictionary <string, ConfigurationVersion> configs)
{
if (configs != null && configs.Count > 0)
{
ConfigurationVersion latestConfig = null;
double number = 0;
foreach (KeyValuePair <string, ConfigurationVersion> config in configs)
{
latestConfig = config.Value as ConfigurationVersion;
if (latestConfig.ConfigVersion > number)
{
number = latestConfig.ConfigVersion;
}
}
return(number);
}
return(0);
}
public bool IsMetaMessageAlreadyKnown(string publisherID, ushort writerID, ConfigurationVersion cfg)
{
if (string.IsNullOrWhiteSpace(publisherID))
{
return(false);
}
if (!m_DeviceMetaMessages.ContainsKey(publisherID))
{
return(false);
}
ConcurrentDictionary <ushort, ConcurrentDictionary <ConfigurationVersion, MetaFrame> > writerIDs = m_DeviceMetaMessages[publisherID];
if (!writerIDs.ContainsKey(writerID))
{
return(false);
}
ConcurrentDictionary <ConfigurationVersion, MetaFrame> metaMessages = writerIDs[writerID];
return(metaMessages.ContainsKey(cfg));
}
/// <summary>
/// Decodes just the DataSetMetaData Message omitting the DiscoveryResponse Header.
/// </summary>
/// <param name="inputStream"></param>
/// <param name="instance"></param>
/// <returns></returns>
protected static bool DeocdeChunk(Stream inputStream, EncodingOptions options, ref MetaFrame instance)
{
instance.DataSetWriterID = BaseType.ReadUInt16(inputStream)
.Value;
instance.Namespaces = ParseNamespaceArray(inputStream);
instance.StructureDataTypes = ParseStructureDescriptions(inputStream);
// if (instance.StructureDataTypes != null)
// DataPointsManager.UpdateStructureDescription(instance.StructureDataTypes);
instance.EnumDataTypes = ParseEnumDescriptions(inputStream);
// Simple Data Types are currently not supported
int?arrayLength = BaseType.ReadInt32(inputStream);
if (arrayLength > 0)
{
// Simple Data Types are not supported
// ToDo: Log error
return(false);
}
instance.Name = String.Decode(inputStream);
instance.Description = LocalizedText.Decode(inputStream);
instance.FieldMetaDataList = ParseFieldMetaDataArray(inputStream, options);
byte[] guidAsByte = Common.ReadBytes(inputStream, 16);
if (guidAsByte != null && guidAsByte.Length == 16)
{
instance.DataSetClassID = new Guid(guidAsByte);
}
instance.ConfigurationVersion = ConfigurationVersion.Decode(inputStream);
uint?readValue = BaseType.ReadUInt32(inputStream);
if (readValue != null)
{
instance.StatusCode = readValue.Value;
}
else
{
return(false);
}
return(true);
}
public static string GetLatestSettingsConfiguration(IDictionary <string, ConfigurationVersion> configs)
{
if (configs != null && configs.Count > 0)
{
string latestserver = null;
ConfigurationVersion latestConfig = null;
double number = 0;
foreach (KeyValuePair <string, ConfigurationVersion> config in configs)
{
latestConfig = config.Value as ConfigurationVersion;
if (latestConfig.ConfigVersion > number)
{
number = latestConfig.ConfigVersion;
latestserver = config.Key.ToString();
}
}
return(latestserver);
}
return(null);
}
private void UpgradeConfigIfNeeded(string file)
{
string Text = string.Empty;
ConfigurationVersion Ver = Parser.GetVersion(TheLauncher.SelectedConfig);
if (Ver < Launcher.CurrentVersion)
{
AppLogger.Log("An outdated config file selected.");
Text += "Selected config file doesn't match the current version of the nDisplayLauncher. ";
Text += "Would you like to convert this file automatically? A new file will be created and added to the list.";
System.Windows.Forms.DialogResult dialogResult = System.Windows.Forms.MessageBox.Show(Text, "Wrong config file format", MessageBoxButtons.YesNo);
if (dialogResult == System.Windows.Forms.DialogResult.Yes)
{
string NewFile = string.Empty;
if (PerformConfigUpgrade(TheLauncher.SelectedConfig, ref NewFile))
{
Text = "Conversion successful. The newly created file was added to the list.\n";
Text += NewFile;
Text += "\nDon't forget to deploy the new config file to your remote machines.";
System.Windows.Forms.MessageBox.Show(Text, "Success", MessageBoxButtons.OK);
}
else
{
Text = "Conversion failed. Please try to upgrade the configuration file manually.";
System.Windows.Forms.MessageBox.Show(Text, "Failed", MessageBoxButtons.OK);
}
}
else
{
AppLogger.Log("Config file upgrade skipped.");
}
}
else if (Ver > Launcher.CurrentVersion)
{
Text = "Incompatible configuration file";
System.Windows.Forms.MessageBox.Show(Text, "Failed", MessageBoxButtons.OK);
}
}
/// <summary>
/// Create service model from api model
/// </summary>
public DataSetMetaDataModel ToServiceModel()
{
return(new DataSetMetaDataModel {
Name = Name,
ConfigurationVersion = ConfigurationVersion?.ToServiceModel(),
DataSetClassId = DataSetClassId,
Description = Description?.ToServiceModel(),
Fields = Fields?
.Select(f => f.ToServiceModel())
.ToList(),
EnumDataTypes = EnumDataTypes?
.Select(f => f.ToServiceModel())
.ToList(),
StructureDataTypes = StructureDataTypes?
.Select(f => f.ToServiceModel())
.ToList(),
SimpleDataTypes = SimpleDataTypes?
.Select(f => f.ToServiceModel())
.ToList(),
Namespaces = Namespaces?.ToList()
});
}
/// <summary>
/// Encodes just the DataSetMetaData message to the given Stream.
/// NetworkMessage Header and DiscoveryResponse are not encoded.
/// </summary>
/// <param name="outputStream"></param>
public void EncodeChunk(Stream outputStream)
{
DiscoveryResponseHeader.Encode(outputStream);
// DataSetWriterID
BaseType.WriteToStream(outputStream, BitConverter.GetBytes(DataSetWriterID));
EncodeDataTypeSchemaHeaderStructure(outputStream);
// Name
Name.Encode(outputStream);
// Description
Description.Encode(outputStream);
// Fields
int fieldLength = -1;
if (FieldMetaDataList != null)
{
fieldLength = FieldMetaDataList.Count;
}
BaseType.WriteToStream(outputStream, BitConverter.GetBytes(fieldLength));
for (int i = 0; i < fieldLength; i++)
{
// ReSharper disable once PossibleNullReferenceException
FieldMetaData field = FieldMetaDataList[i] ?? new FieldMetaData(Options);
field.Encode(outputStream);
}
// DataSet Class ID
BaseType.WriteToStream(outputStream, DataSetClassID.ToByteArray());
// Version
ConfigurationVersion.Encode(outputStream);
// Status Code
BaseType.WriteToStream(outputStream, BitConverter.GetBytes(StatusCode));
}
public void StoreMetaMessageLocally(MetaFrame metaFrame)
{
string pubID = metaFrame.NetworkMessageHeader.PublisherID.Value;
ConfigurationVersion configVersion = metaFrame.ConfigurationVersion;
ushort writerID = metaFrame.DataSetWriterID;
if (IsMetaMessageAlreadyKnown(pubID, writerID, configVersion))
{
return;
}
if (Logger.IsInfoEnabled)
{
Logger.Info($"Storing meta message for {pubID} with version {configVersion}.");
}
if (!m_DeviceMetaMessages.TryGetValue(pubID, out ConcurrentDictionary <ushort, ConcurrentDictionary <ConfigurationVersion, MetaFrame> > publisherDictionary))
{
publisherDictionary = new ConcurrentDictionary <ushort, ConcurrentDictionary <ConfigurationVersion, MetaFrame> >();
m_DeviceMetaMessages.TryAdd(pubID, publisherDictionary);
}
if (!publisherDictionary.TryGetValue(writerID, out ConcurrentDictionary <ConfigurationVersion, MetaFrame> cfgDictionary))
{
cfgDictionary = new ConcurrentDictionary <ConfigurationVersion, MetaFrame>();
publisherDictionary.TryAdd(writerID, cfgDictionary);
}
if (cfgDictionary.Count > 10)
{
MetaFrame dummy;
cfgDictionary.TryRemove(cfgDictionary.Keys.OrderBy(a => a)
.First(),
out dummy
);
}
// Add the Meta Message if it doesn't exist yet or if it's already present, replace it.
cfgDictionary.AddOrUpdate(configVersion, metaFrame, (existingVersion, existingFrame) => metaFrame);
}
/// <summary>
/// Encodes just the common part of the DataSet Message (e.g. Flags 1 & Flags 2,
/// Configuration Version and Message Sequence Number.
/// </summary>
/// <param name="outputStream"></param>
public virtual void EncodeChunk(Stream outputStream)
{
// 3. DataSetFlags1
outputStream.WriteByte(Flags1.RawValue);
// 4. DataSetFlags2
if (Flags1.Flags1.HasFlag(DataSetFlags1Enum.DataSetFlags2Enabled))
{
outputStream.WriteByte(Flags2.RawValue);
}
// 5. Message Sequence Number
if (Flags1.Flags1.HasFlag(DataSetFlags1Enum.DataSetSequenceNumberEnabled))
{
BaseType.WriteToStream(outputStream, BitConverter.GetBytes(DataSetMessageSequenceNumber));
}
// evaluate the following options only if DataSetFlags2 field is provided
if (Flags1.Flags1.HasFlag(DataSetFlags1Enum.DataSetFlags2Enabled))
{
// Timestamp
if (Flags2.Flags2.HasFlag(DataSetFlags2Enum.TimeStampEnabled))
{
BaseType.WriteToStream(outputStream, BitConverter.GetBytes(Convert.ToInt64(Timestamp.ToFileTimeUtc())));
}
}
// 6. Configuration Version
if (Flags1.Flags1.HasFlag(DataSetFlags1Enum.ConfigurationVersionMajorVersion) ||
Flags1.Flags1.HasFlag(DataSetFlags1Enum.ConfigurationVersionMinorVersion))
{
// we always send both, minor and major version; ensure that both
// bits are set in DataSetFlags1
ConfigurationVersion.Encode(outputStream);
}
}
public static ConversionResult Convert(string OrigFile, ConfigurationVersion ToVerison)
{
ConversionResult Result = new ConversionResult();
ConfigurationVersion Ver = Parser.GetVersion(OrigFile);
try
{
string OldFile = OrigFile;
for (int i = (int)Ver + 1; i <= (int)Launcher.CurrentVersion; ++i)
{
Result.NewConfigFile = OldFile.Insert(OldFile.Length - ".cfg".Length, "." + ((ConfigurationVersion)i).ToString());
IConfigConverter Converter = ConverterFactory.CreateConverter((ConfigurationVersion)i);
if (Converter == null)
{
AppLogger.Log("Unknown config format");
return(Result);
}
Result.Success = Converter.Convert(OldFile, Result.NewConfigFile);
if (!Result.Success)
{
throw new Exception(string.Format("Couldn't convert\n%s\n\to\n%s", OldFile, Result.NewConfigFile));
}
OldFile = Result.NewConfigFile;
}
}
catch (Exception ex)
{
AppLogger.Log("Conversion error: " + ex.Message);
}
return(Result);
}
public static bool DecodeChunk(Stream inputStream, ref DataFrame instance)
{
// 3. DataSetFlags1
instance.Flags1.RawValue = (byte)inputStream.ReadByte();
// 4. DataSetFlags2
if (instance.Flags1.Flags1.HasFlag(DataSetFlags1Enum.DataSetFlags2Enabled))
{
instance.Flags2.RawValue = (byte)inputStream.ReadByte();
}
// 5. Message Sequence Number
if (instance.Flags1.Flags1.HasFlag(DataSetFlags1Enum.DataSetSequenceNumberEnabled))
{
ushort?sequence = BaseType.ReadUInt16(inputStream);
if (sequence != null)
{
instance.DataSetMessageSequenceNumber = sequence.Value;
}
else
{
// ToDo: Log error
return(false);
}
}
// evaluate the following options only if DataSetFlags2 field is provided
if (instance.Flags1.Flags1.HasFlag(DataSetFlags1Enum.DataSetFlags2Enabled))
{
// Timestamp
if (instance.Flags2.Flags2.HasFlag(DataSetFlags2Enum.TimeStampEnabled))
{
long?timestamp = BaseType.ReadInt64(inputStream);
if (timestamp != null)
{
instance.Timestamp = DateTime.FromFileTimeUtc(timestamp.Value);
//instance.Timestamp = DateTime.FromBinary(timestamp.Value);
}
else
{
// ToDo: Log error
return(false);
}
}
}
// 6. Major & Minor
//
// we always expect both, minor and major version; ensure that both
// bits are set in DataSetFlags1
//
if (instance.Flags1.Flags1.HasFlag(DataSetFlags1Enum.ConfigurationVersionMajorVersion))
{
if (instance.Flags1.Flags1.HasFlag(DataSetFlags1Enum.ConfigurationVersionMinorVersion))
{
// read minor and major version, must both exist
instance.ConfigurationVersion = ConfigurationVersion.Decode(inputStream);
}
else
{
throw new Exception("DataSetMessageHeader: Minor Configuration Version not present.");
}
}
else
{
if (instance.Flags1.Flags1.HasFlag(DataSetFlags1Enum.ConfigurationVersionMinorVersion))
{
throw new Exception("DataSetMessageHeader: Major Configuration Version not present.");
}
}
return(true);
}
public override void InitializeFromText(string text)
{
string StrVersion = Parser.GetStringValue("version", text);
Version = ConfigurationVersionHelpers.FromString(StrVersion);
}
public MetaFrame RetrieveMetaMessageLocally(string publisherId, ushort writerID, ConfigurationVersion cfgVersion)
{
if (string.IsNullOrEmpty(publisherId))
{
return(null);
}
if (!m_DeviceMetaMessages.TryGetValue(publisherId,
out ConcurrentDictionary <ushort, ConcurrentDictionary <ConfigurationVersion, MetaFrame> > deviceMetaMessages
))
{
return(null);
}
if (!deviceMetaMessages.TryGetValue(writerID, out ConcurrentDictionary <ConfigurationVersion, MetaFrame> metaDictionary))
{
return(null);
}
if (!metaDictionary.TryGetValue(cfgVersion, out MetaFrame metaMessage))
{
return(null);
}
return(metaMessage);
}
