void PingJournal()
{
JournalParser journalParser;
if (IsFirstTimeReadJournal && !String.IsNullOrEmpty(GkDatabase.RootDevice.GetReservedIpAddress())) // Находим последнее событие на КАУ первый раз (при запуске сервера)
{
journalParser = GetKauJournalById(-1);
if (journalParser != null)
LastKauId = journalParser.KauJournalRecordNo;
IsFirstTimeReadJournal = false;
}
using (var gkLifecycleManager = new GKLifecycleManager(GkDatabase.RootDevice, "Проверка журнала"))
{
if (IpAddress != GkDatabase.RootDevice.GetGKIpAddress())
{
if (!String.IsNullOrEmpty(IpAddress))
{
var lastKauJournal = GetKauJournalById(LastKauId);
if (lastKauJournal != null)
LastId = lastKauJournal.GKJournalRecordNo;
}
IpAddress = GkDatabase.RootDevice.GetGKIpAddress();
}
var newLastId = GetLastId();
if (newLastId == -1)
return;
if (LastId == -1)
LastId = newLastId;
if (newLastId > LastId)
{
for (int index = LastId + 1; index <= newLastId; index++)
{
gkLifecycleManager.Progress(index - LastId, newLastId - LastId);
journalParser = ReadAndPublish(index);
if (journalParser != null && journalParser.KauJournalRecordNo != 0)
LastKauId = journalParser.KauJournalRecordNo;
}
LastId = newLastId;
gkLifecycleManager.AddItem("Изменение индекса в БД");
using (var skdDatabaseService = new RubezhDAL.DataClasses.DbService())
{
var gkIpAddress = GKManager.GetIpAddress(GkDatabase.RootDevice);
skdDatabaseService.GKMetadataTranslator.SetLastJournalNo(gkIpAddress, LastId);
}
}
}
}
public void WriteConfig(GKDevice gkControllerDevice, GKProgressCallback progressCallback, Guid clientUID)
{
Errors = new List<string>();
progressCallback = GKProcessorManager.StartProgress("Запись конфигурации", "Проверка связи", 1, false, GKProgressClientType.Administrator, clientUID);
try
{
var gkDatabase = DescriptorsManager.GkDatabases.FirstOrDefault(x => x.RootDevice.UID == gkControllerDevice.UID);
if (gkDatabase != null)
{
var kauDatabases = new List<KauDatabase>();
var lostKauDatabases = new List<KauDatabase>();
using (var gkLifecycleManager = new GKLifecycleManager(gkDatabase.RootDevice, "Проверка связи"))
{
gkLifecycleManager.AddItem("ГК");
var pingResult = DeviceBytesHelper.Ping(gkDatabase.RootDevice);
if (pingResult.HasError)
{
Errors.Add("Устройство " + gkDatabase.RootDevice.PresentationName + " недоступно");
return;
}
foreach (var kauDatabase in gkDatabase.KauDatabases)
{
gkLifecycleManager.AddItem(kauDatabase.RootDevice.PresentationName);
pingResult = DeviceBytesHelper.Ping(kauDatabase.RootDevice);
if (!pingResult.HasError)
{
kauDatabases.Add(kauDatabase);
}
else
{
lostKauDatabases.Add(kauDatabase);
}
}
}
for (int i = 0; i < 3; i++)
{
Errors = new List<string>();
var summaryDescriptorsCount = 4 + gkDatabase.Descriptors.Count;
kauDatabases.ForEach(x => { summaryDescriptorsCount += 3 + x.Descriptors.Count; });
var title = "Запись конфигурации в " + gkDatabase.RootDevice.PresentationName + (i > 0 ? " Попытка " + (i + 1) : "");
progressCallback = GKProcessorManager.StartProgress(title, "", summaryDescriptorsCount, false, GKProgressClientType.Administrator, clientUID);
var result = DeviceBytesHelper.GoToTechnologicalRegime(gkDatabase.RootDevice, progressCallback, clientUID);
if (!result)
{
Errors.Add("Не удалось перевести " + gkControllerDevice.PresentationName + " в технологический режим\nУстройство не доступно, либо вашего IP адреса нет в списке разрешенного адреса ГК");
continue;
}
result = DeviceBytesHelper.EraseDatabase(gkDatabase.RootDevice, progressCallback, clientUID);
if (!result)
{
Errors.Add("Не удалось стереть базу данных ГК");
continue;
}
foreach (var kauDatabase in kauDatabases)
{
result = DeviceBytesHelper.GoToTechnologicalRegime(kauDatabase.RootDevice, progressCallback, clientUID);
if (!result)
{
Errors.Add("Не удалось перевести КАУ в технологический режим");
continue;
}
if (!DeviceBytesHelper.EraseDatabase(kauDatabase.RootDevice, progressCallback, clientUID))
{
Errors.Add("Не удалось стереть базу данных КАУ");
continue;
}
if (!WriteConfigToDevice(kauDatabase, progressCallback, clientUID))
{
Errors.Add("Не удалось записать дескриптор КАУ");
}
}
result = WriteConfigToDevice(gkDatabase, progressCallback, clientUID);
if (!result)
{
Errors.Add("Не удалось записать дескриптор ГК");
continue;
}
var gkFileReaderWriter = new GKFileReaderWriter();
gkFileReaderWriter.WriteFileToGK(gkControllerDevice, clientUID);
if (gkFileReaderWriter.Error != null)
{
Errors.Add(gkFileReaderWriter.Error);
break;
}
foreach (var kauDatabase in kauDatabases)
{
if (!DeviceBytesHelper.GoToWorkingRegime(kauDatabase.RootDevice, progressCallback, clientUID, kauDatabase.RootDevice.Driver.IsKau))
{
Errors.Add("Не удалось перевести " + kauDatabase.RootDevice.PresentationName + " в рабочий режим");
}
}
if (!DeviceBytesHelper.GoToWorkingRegime(gkDatabase.RootDevice, progressCallback, clientUID, false))
{
Errors.Add("Не удалось перевести " + gkDatabase.RootDevice + " в рабочий режим");
}
break;
}
foreach (var kauDatabase in lostKauDatabases)
{
Errors.Add("Устройство " + kauDatabase.RootDevice.PresentationName + " недоступно");
}
}
}
catch (Exception e)
{
Logger.Error(e, "GKDescriptorsWriter.WriteConfig");
Errors.Add(e.Message);
}
finally
{
if (progressCallback != null)
GKProcessorManager.StopProgress(progressCallback, clientUID);
}
}
bool WriteConfigToDevice(CommonDatabase commonDatabase, GKProgressCallback progressCallback, Guid clientUID)
{
using (var gkLifecycleManager = new GKLifecycleManager(commonDatabase.RootDevice, "Запись дескрипторов"))
{
for (int descriptorNo = 0; descriptorNo < commonDatabase.Descriptors.Count; descriptorNo++)
{
var descriptor = commonDatabase.Descriptors[descriptorNo];
gkLifecycleManager.Progress(descriptorNo + 1, commonDatabase.Descriptors.Count);
var progressStage = commonDatabase.RootDevice.PresentationName + ": запись " + descriptor.GKBase.PresentationName + " " + "(" + descriptor.GetDescriptorNo() + ")" + " из " + commonDatabase.Descriptors.Count;
GKProcessorManager.DoProgress(progressStage, progressCallback, clientUID);
var packs = CreateDescriptors(descriptor);
foreach (var pack in packs)
{
for (int i = 0; i < 10; i++)
{
var sendResult = SendManager.Send(commonDatabase.RootDevice, (ushort)(pack.Count), 17, 0, pack);
if (sendResult.HasError)
{
if (i >= 9)
{
GKProcessorManager.StopProgress(progressCallback, clientUID);
gkLifecycleManager.AddItem("Ошибка");
return false;
}
}
else
break;
}
}
}
GKProcessorManager.DoProgress(commonDatabase.RootDevice.PresentationName + " Запись завершающего дескриптора", progressCallback, clientUID);
WriteEndDescriptor(commonDatabase);
return true;
}
}
public void WriteFileToGK(GKDevice gkControllerDevice, Guid clientUID)
{
using (var gkLifecycleManager = new GKLifecycleManager(gkControllerDevice, "Запись файла в ГК"))
{
gkLifecycleManager.AddItem("Формирование хэша");
var gkFileInfo = new GKFileInfo();
gkFileInfo.Initialize(gkControllerDevice);
var bytesList = new List<byte>();
bytesList.AddRange(gkFileInfo.InfoBlock);
bytesList.AddRange(gkFileInfo.FileBytes);
gkLifecycleManager.AddItem("Перевод в режим записи файла");
var sendResult = SendManager.Send(gkControllerDevice, 0, 21, 0);
if (sendResult.HasError)
{
Error = "Невозможно начать процедуру записи ";
gkLifecycleManager.AddItem("Ошибка");
return;
}
var progressCallback = GKProcessorManager.StartProgress("Запись файла в " + gkControllerDevice.PresentationName, null, bytesList.Count / 256, false, GKProgressClientType.Administrator, clientUID);
for (var i = 0; i < bytesList.Count; i += 256)
{
gkLifecycleManager.Progress(i + 1, bytesList.Count);
GKProcessorManager.DoProgress("Запись блока данных " + i + 1, progressCallback, clientUID);
var bytesBlock = BitConverter.GetBytes((uint)(i / 256 + 1)).ToList();
bytesBlock.AddRange(bytesList.GetRange(i, Math.Min(256, bytesList.Count - i)));
for (int j = 0; j < 10; j++)
{
sendResult = SendManager.Send(gkControllerDevice, (ushort)bytesBlock.Count(), 22, 0, bytesBlock);
var result = sendResult.Bytes.Count > 0 && sendResult.Bytes[0] == 1;
if (!sendResult.HasError && result)
break;
if (j == 9)
{
Error = "Невозможно записать блок данных " + i;
gkLifecycleManager.AddItem("Ошибка");
return;
}
}
}
gkLifecycleManager.AddItem("Запись последнего блока данных");
var endBlock = BitConverter.GetBytes((uint)(bytesList.Count() / 256 + 1)).ToList();
sendResult = SendManager.Send(gkControllerDevice, 0, 22, 0, endBlock);
var endResult = sendResult.Bytes.Count > 0 && sendResult.Bytes[0] == 0;
if (sendResult.HasError || !endResult)
{
Error = "Невозможно завершить запись файла ";
gkLifecycleManager.AddItem("Ошибка");
}
var sendResultRead = SendManager.Send(gkControllerDevice, 4, 23, 256, new List<byte>(BitConverter.GetBytes(1)));
if (!gkFileInfo.InfoBlock.SequenceEqual(sendResultRead.Bytes))
{
Error = "Не удалось корректно записать информационный блок ";
gkLifecycleManager.AddItem("Ошибка");
}
}
}
public OperationResult<string> ReadConfigFileFromGK(GKDevice gkControllerDevice, GKProgressCallback progressCallback, Guid clientUID)
{
progressCallback = GKProcessorManager.StartProgress("Чтение конфигурационного файла из " + gkControllerDevice.PresentationName, "Проверка связи", 1, true, GKProgressClientType.Administrator, clientUID);
try
{
using (var gkLifecycleManager = new GKLifecycleManager(gkControllerDevice, "Чтение файла ГК"))
{
gkLifecycleManager.AddItem("Чтение информационного блока");
var gkFileInfo = ReadInfoBlock(gkControllerDevice);
if (Error != null)
{
gkLifecycleManager.AddItem("Ошибка чтения информационного блока");
return OperationResult<string>.FromError("Ошибка чтения информационного блока");
}
var allbytes = new List<byte>();
uint i = 2;
progressCallback = GKProcessorManager.StartProgress("Чтение конфигурационного файла из " + gkControllerDevice.PresentationName, "", (int)(gkFileInfo.FileSize / 256), true, GKProgressClientType.Administrator, clientUID);
while (true)
{
if (progressCallback.IsCanceled)
return OperationResult<string>.FromError("Операция отменена");
GKProcessorManager.DoProgress("Чтение блока данных " + i, progressCallback, clientUID);
gkLifecycleManager.Progress((int)i, (int)(gkFileInfo.FileSize / 256));
var data = new List<byte>(BitConverter.GetBytes(i++));
var sendResultBytesCount = 256;
for (int j = 0; j < 10; j++)
{
var sendResult = SendManager.Send(gkControllerDevice, 4, 23, 256, data);
allbytes.AddRange(sendResult.Bytes);
sendResultBytesCount = sendResult.Bytes.Count();
if (!sendResult.HasError)
break;
if (j == 9)
{
return OperationResult<string>.FromError("Невозможно прочитать блок данных " + i);
}
}
if (sendResultBytesCount < 256)
break;
}
if (allbytes.Count == 0)
return OperationResult<string>.FromError("Конфигурационный файл отсутствует");
var folderName = AppDataFolderHelper.GetFolder("TempServer");
var configFileName = Path.Combine(folderName, "ConfigFromGK.fscp");
if (Directory.Exists(folderName))
Directory.Delete(folderName, true);
Directory.CreateDirectory(folderName);
var fileStream = new FileStream(configFileName, FileMode.CreateNew, FileAccess.ReadWrite);
fileStream.Write(allbytes.ToArray(), 0, allbytes.Count);
fileStream.Close();
return new OperationResult<string>(configFileName);
}
}
catch (Exception e)
{
Logger.Error(e, "GKDescriptorsWriter.WriteConfig");
return OperationResult<string>.FromError("Непредвиденная ошибка");
}
finally
{
if (progressCallback != null)
GKProcessorManager.StopProgress(progressCallback, clientUID);
}
}
void RunMonitoring()
{
using (var gkLifecycleManager = new GKLifecycleManager(GkDatabase.RootDevice, "Цикл мониторинга"))
{
gkLifecycleManager.AddItem("Проверка лицензии");
var hasLicense = LicenseManager.CurrentLicenseInfo.LicenseMode != LicenseMode.NoLicense;
if (HasLicense != hasLicense)
{
HasLicense = hasLicense;
foreach (var descriptor in GkDatabase.Descriptors)
{
descriptor.GKBase.InternalState.IsNoLicense = !HasLicense;
}
NotifyAllObjectsStateChanged();
}
if (!hasLicense)
return;
if (WatcherManager.IsConfigurationReloading)
{
if ((DateTime.Now - WatcherManager.LastConfigurationReloadingTime).TotalSeconds > 100)
WatcherManager.IsConfigurationReloading = false;
}
if (WatcherManager.IsConfigurationReloading)
return;
if (IsDBMissmatchDuringMonitoring)
{
if ((DateTime.Now - LastMissmatchCheckTime).TotalSeconds > 60)
{
gkLifecycleManager.AddItem("Ошибка сопоставления конфигурации. Опрос объектов");
GetAllStates();
LastMissmatchCheckTime = DateTime.Now;
}
return;
}
try
{
if (MustCheckTechnologicalRegime)
{
if ((DateTime.Now - LastTechnologicalRegimeCheckTime).TotalSeconds > 10)
{
LastTechnologicalRegimeCheckTime = DateTime.Now;
CheckTechnologicalRegime();
NotifyAllObjectsStateChanged();
TechnologicalRegimeCheckCount++;
if (TechnologicalRegimeCheckCount >= 10)
MustCheckTechnologicalRegime = false;
}
}
}
catch (Exception e)
{
Logger.Error(e, "Watcher.OnRunThread CheckTechnologicalRegime");
}
try
{
gkLifecycleManager.AddItem("Проверка задач");
CheckTasks();
}
catch (Exception e)
{
Logger.Error(e, "Watcher.OnRunThread CheckTasks");
}
try
{
gkLifecycleManager.AddItem("Проверка задержек");
CheckDelays();
}
catch (Exception e)
{
Logger.Error(e, "Watcher.OnRunThread CheckDelays");
}
try
{
PingJournal();
}
catch (Exception e)
{
Logger.Error(e, "Watcher.OnRunThread PingJournal");
}
try
{
gkLifecycleManager.AddItem("Проверка измерений");
CheckMeasure();
}
catch (Exception e)
{
Logger.Error(e, "Watcher.OnRunThread CheckMeasure");
}
try
{
if ((DateTime.Now - LastKAUMeasureTime) > TimeSpan.FromHours(1))
{
LastKAUMeasureTime = DateTime.Now;
gkLifecycleManager.AddItem("Измерение токопотребления");
CheckKAUMeasure();
}
}
catch (Exception e)
{
Logger.Error(e, "Watcher.OnRunThread CheckKAUMeasure");
}
}
}
bool CheckTechnologicalRegime()
{
using (var gkLifecycleManager = new GKLifecycleManager(GkDatabase.RootDevice, "Проверка технологического режима"))
{
gkLifecycleManager.AddItem(GkDatabase.RootDevice.PresentationName);
var isInTechnologicalRegime = DeviceBytesHelper.IsInTechnologicalRegime(GkDatabase.RootDevice);
gkLifecycleManager.AddItem("Обновление состояний технологического режима");
foreach (var descriptor in GkDatabase.Descriptors)
{
descriptor.GKBase.InternalState.IsInTechnologicalRegime = isInTechnologicalRegime;
}
if (!isInTechnologicalRegime)
{
foreach (var kauDatabase in GkDatabase.KauDatabases)
{
gkLifecycleManager.AddItem(kauDatabase.RootDevice.PresentationName);
var isKAUInTechnologicalRegime = DeviceBytesHelper.IsInTechnologicalRegime(kauDatabase.RootDevice);
gkLifecycleManager.AddItem("Обновление состояний технологического режима");
foreach (var device in kauDatabase.RootDevice.AllChildrenAndSelf)
{
device.InternalState.IsInTechnologicalRegime = isKAUInTechnologicalRegime;
}
}
}
return isInTechnologicalRegime;
}
}