/// <summary>
/// Model-checks a scenario where the goal is not reachable.
/// </summary>
/// <returns>The model check result.</returns>
public static ModelCheckReport <Constants, Variables> CheckImpossible()
{
List <int> jugs = new List <int> {
1, 2, 3
};
Dictionary <int, int> jugCapacities = new Dictionary <int, int>
{
[jugs[0]] = 2,
[jugs[1]] = 4,
[jugs[2]] = 8,
};
Constants constants = new Constants(jugs, jugCapacities);
IInitialStates <Constants, Variables> init = new InitialStateGenerator();
INextStateRelation <Constants, Variables> nextStateRelation = BuildNextStateRelation(constants);
ISafetyInvariant <Constants, Variables> safetyInvariant = new SafetyProperties();
ISafetyInvariant <Constants, Variables> goal = new Goal(3);
return(ModelCheck <Constants, Variables> .CheckModel(
constants,
init,
nextStateRelation,
safetyInvariant,
goal));
}
/// <summary>
/// Most basic model/version check using Regex on the SysVersion
/// </summary>
/// <param name="modelCheck"></param>
/// <param name="sysVersion"></param>
/// <returns></returns>
private (string model, string version) basicSysVersionCheck(ModelCheck modelCheck, string sysVersion)
{
var model = "";
var version = "";
Regex modelRegex = new Regex(modelCheck.Regex, RegexOptions.IgnoreCase);
var matches = modelRegex.Matches(sysVersion);
if (matches.Count > 0)
{
if (matches?[0].Groups["Model"]?.Value != null)
{
model = matches[0].Groups["Model"].Value;
}
;
if (matches?[0].Groups["Version"]?.Value != null)
{
version = matches[0].Groups["Version"].Value;
}
;
}
else
{
model = "ModelCheck Failed";
version = sysVersion;
}
return(model, version);
}
/// <summary>
/// Finds which model check to use, then uses the appropriate SysVersion check to get the correct model and version
/// </summary>
/// <param name="sysVersion"></param>
/// <param name="community"></param>
/// <param name="_config"></param>
private void findSysVersionModel(string sysVersion, string community, Configuration _config)
{
if (_deviceType != null)
{
ModelCheck mc = getModelCheck(_deviceType, sysVersion);
if (mc != null)
{
if (string.IsNullOrWhiteSpace(mc.Regex))
{
(Model, Version) = altSysVersionChecks(mc, new IPAddressValue {
IPAddress = IpAddress, Community = community
}, _config);
}
else
{
(Model, Version) = basicSysVersionCheck(mc, sysVersion);
}
}
else
{
Model = "Unknown";
Errors = "Device passed a known type, but failed to match the provided regex.";
Version = SysVersion;
}
}
else
{
Model = "Unknown";
Errors = "Unknown Device Type, Check ObjectOID vs Config.json.";
Version = SysVersion;
}
}
public static void CreateTable <T>(this DbContext dbContext)
{
var dbExtend = GetDBExtend(dbContext);
ModelCheck.CreateTable(typeof(T), dbExtend as AbsDBExtend, out var message);
Console.WriteLine(message);
}
/// <summary>
/// If we don't have a regex that combines Model and Version, we use this routine to check various other models
/// Including Fixed, Regex and SNMP methods for fetching valid Model/Version
/// </summary>
/// <param name="modelCheck"></param>
/// <param name="address"></param>
/// <param name="config"></param>
/// <returns></returns>
private (string model, string version) altSysVersionChecks(ModelCheck modelCheck, IPAddressValue address, Configuration config)
{
var model = "";
var version = "";
// Use a fixed model (worst case)
if (modelCheck.ModelFixed != "")
{
model = modelCheck.ModelFixed;
}
// Use a fixed Version (why would we want to, but oh well)
if (modelCheck.VersionFixed != "")
{
model = modelCheck.VersionFixed;
}
// Use a custom regex of sysVersion to grab Version
if (modelCheck.ModelRegex != "")
{
Regex r = new Regex(modelCheck.ModelRegex, RegexOptions.IgnoreCase);
var mR = r.Matches(SysVersion);
if (mR.Count > 0)
{
model = mR[0].Groups["Model"].Value;
}
}
// Use a custom regex of sysVersion to grab Version
if (modelCheck.VersionRegex != "")
{
Regex r = new Regex(modelCheck.VersionRegex, RegexOptions.IgnoreCase);
var mR = r.Matches(SysVersion);
if (mR.Count > 0)
{
version = mR[0].Groups["Version"].Value;
}
}
// Fetch Model/Version from SNMP directly if it's set
if (modelCheck.ModelSnmp != "" || modelCheck.VersionSnmp != "")
{
var snmp = new SnmpTools(config);
// Grab Model from SNMP if it's supplied
if (modelCheck.ModelSnmp != "")
{
model = snmp.GetSnmpStringWithFallback(address, modelCheck.ModelSnmp);
}
// Grab Version from SNMP if it's supplied
if (modelCheck.VersionSnmp != "")
{
version = snmp.GetSnmpStringWithFallback(address, modelCheck.VersionSnmp);
}
}
return(model, version);
}
public override void CreateTableIndex <TModel>()
{
var type = typeof(TModel);
var columns = ModelCheck.GetColumns(type, this);
foreach (Attribute.FieldInnerAttribute item in columns)
{
if (item.FieldIndexType != Attribute.FieldIndexType.无)
{
var indexKeys = Builders <TModel> .IndexKeys.Ascending(item.MemberName);
GetCollection <TModel>().Indexes.CreateOne(indexKeys);
}
}
}
static void DoCheck()
{
if (needCheks.Count == 0)
{
return;
}
var list = new Dictionary <Type, string>(needCheks);
foreach (var item in list)
{
var db = dBExtends[item.Value];//todo 线程安全,对象在别的地方被使用过了,导至异常
var table = TypeCache.GetTable(item.Key);
var _DBAdapter = DBAdapter.DBAdapterBase.GetDBAdapterBase(db.dbContext);
var sql = _DBAdapter.GetTableFields(table.TableName);
var allFileds = db.ExecDictionary <string, int>(sql);
var allFileds2 = new Dictionary <string, int>();
foreach (var f in allFileds)
{
allFileds2.Add(f.Key.ToLower(), 0);
}
var fields = table.Fields;
var needCreates = new List <Attribute.FieldAttribute>();
foreach (var field in fields)
{
if (field.FieldType != Attribute.FieldType.数据库字段)
{
continue;
}
if (!allFileds2.ContainsKey(field.MemberName.ToLower()))
{
needCreates.Add(field);
}
}
//var model = System.Activator.CreateInstance(item.Key) as IModel;
foreach (var field in needCreates)
{
ModelCheck.SetColumnDbType(_DBAdapter, field);
string str = ModelCheck.CreateColumn(db, field);
}
string val;
needCheks.TryRemove(item.Key, out val);
}
}
/// <summary>
/// 检查表是否被创建
/// </summary>
internal override void CheckTableCreated(Type type)
{
if (!SettingConfig.CheckModelTableMaping)
{
return;
}
if (!type.IsSubclassOf(typeof(IModel)))
{
return;
}
if (!tableCheckedCache.ContainsKey(type))
{
tableCheckedCache.TryAdd(type, false);
}
if (tableCheckedCache[type] == true)
{
return;
}
//TypeCache.SetDBAdapterCache(type, _DBAdapter);
var dbName = DatabaseName;
var cacheInstance = CRL.ExistsTableCache.ExistsTableCache.Instance;
var table = TypeCache.GetTable(type);
AbsDBExtend db;
if (!cacheInstance.DataBase.ContainsKey(dbName))
{
db = GetBackgroundDBExtend();
#region 初始表
lock (lockObj)
{
//BackupParams();
string sql = _DBAdapter.GetAllTablesSql();
var dic = db.ExecDictionary <string, int>(sql);
//RecoveryParams();
cacheInstance.InitTable(dbName, dic.Keys.ToList());
}
#endregion
}
var tableName = TypeCache.GetTableName(table.TableName, dbContext);
var tb = cacheInstance.GetTable(dbName, tableName);
if (tb == null)//没有创建表
{
db = GetBackgroundDBExtend();
#region 创建表
//BackupParams();
var obj = System.Activator.CreateInstance(type) as IModel;
var initDatas = obj.GetInitData();
if (initDatas != null)
{
foreach (IModel item in initDatas)
{
CheckData(item);
}
}
string msg;
ModelCheck.CreateTable(type, db, out msg);
cacheInstance.SaveTable(dbName, table, tableName);
if (initDatas != null)
{
_DBAdapter.BatchInsert(initDatas, false);
}
tableCheckedCache[type] = true;
return;
#endregion
}
if (tb.ColumnChecked)
{
tableCheckedCache[type] = true;
return;
}
//判断字段是否一致
var needCreates = CRL.ExistsTableCache.ExistsTableCache.Instance.CheckFieldExists(dbName, table, tableName);
if (needCreates.Count > 0)
{
db = GetBackgroundDBExtend();
#region 创建列
//BackupParams();
foreach (var item in needCreates)
{
ModelCheck.SetColumnDbType(_DBAdapter, item);
try
{
string str = ModelCheck.CreateColumn(db, item);
}
catch { }
}
//RecoveryParams();
#endregion
}
//二次检查,对照表结构
if (!tb.ColumnChecked2)
{
var db2 = copyDBExtend();
ExistsTableCache.ColumnBackgroundCheck.Add(db2, type);
tb.ColumnChecked2 = true;
}
tableCheckedCache[type] = true;
}
