public bool RegisterListListener(LoginSession session, String server, int list)
{
try
{
IListServiceClient callback = _callbackCreator();
lock (_subscribersLock)
{
if (!_subscribers.Exists(client => client.IsCurrentCallback(callback)))
{
_subscribers.Add(new AsyncListServiceClient(callback));
}
_subscribers.Find(client => client.IsCurrentCallback(callback)).AddChannel(new Channel(server, list));
}
CheckClients(null, null);
return(true);
}
catch (CommunicationException ex)
{
ServiceLogger.Error("Error while registering ListListener", ex);
return(false);
}
}
private IEnumerable <MediaInfo> Execute(Expression <Func <MediaInfo, Boolean> > expression)
{
var adcUri = new Uri(
Config.Instance.ConfigObject.DataServiceConnectionOptions.DataServiceAddress);
var adcDB = new AdcModelContainer(adcUri);
var query = adcDB.MediaInfos.Expand(@"ContentTable").Expand(@"SegmentInfos").Where(expression) as DataServiceQuery <MediaInfo>;
var result = new List <MediaInfo>();
if (query != null)
{
try
{
var response = (QueryOperationResponse <MediaInfo>)query.Execute();
while (response != null)
{
var part = new List <MediaInfo>();
part.AddRange(response);
result.AddRange(part);
var continuation = response.GetContinuation();
response = continuation != null?adcDB.Execute(continuation) : null;
}
}
catch (Exception ex)
{
ServiceLogger.Error(ex.Message, ex);
return(result);
}
}
return(result);
}
private void StartHTTPCompanionService(string URL)
{
//URL = Zeus.Lib.Extensions.ExtensionHelpers.GetAddress(URL);
WebServiceHTTP.WebServiceBaseAddress = URL;
string WebServiceHTTPBaseAddress = URL + "Admin/";
try
{
Uri uri = new Uri(WebServiceHTTPBaseAddress);
oWebServiceHost = new WebServiceHost(oServiceHTTPType, uri);
var endpoint = CreateEndpoint(oServiceHTTPInterfaceType, WebServiceHTTPBaseAddress);
oWebServiceHost.AddServiceEndpoint(endpoint);
//oWebServiceHost.Authorization.ServiceAuthorizationManager = new RestAuthorizationManager();
oWebServiceHost.Open();
}
catch (Exception ex)
{
ServiceLogger.Error("Companion service cannot be started, reason: " + ex.Message);
return;
}
ServiceLogger.Info("SERVICE HTML ADMIN STARTED");
ServiceLogger.Info("Listening on: " + WebServiceHTTPBaseAddress);
}
private IEnumerable <ASDB> Execute(Expression <Func <ASDB, Boolean> > expression)
{
var asdbUri = ConfigurationManager.AppSettings.Get("AsdbUri");
var asdbDB = new ASDBModelContainer(new Uri(asdbUri));
var query = asdbDB.ASDBs.Where(expression) as DataServiceQuery <ASDB>;
var result = new List <ASDB>();
if (query != null)
{
try
{
var response = (QueryOperationResponse <ASDB>)query.Execute();
while (response != null)
{
var part = new List <ASDB>();
part.AddRange(response);
result.AddRange(part);
var continuation = response.GetContinuation();
response = continuation != null?asdbDB.Execute(continuation) : null;
}
}
catch (Exception ex)
{
ServiceLogger.Error(ex.Message, ex);
return(result);
}
}
return(result);
}
/// <summary>
/// Запускает импорт
/// </summary>
/// <returns></returns>
public int Start(string path)
{
using (var reader = new StreamReader(path, Encoding.UTF8, true))
{
var serializer = new XmlSerializer(typeof(FLInfoList));
try
{
var arrayOfInfo = (FLInfoList)serializer.Deserialize(reader);
List <SS_FlInfo> list = new List <SS_FlInfo>();
ServiceLogger.Info("{info}", "начало мапинга");
foreach (var item in arrayOfInfo.FLInfos)
{
list.Add(CustomMapper(item));
}
ServiceLogger.Info("{info}", "конец мапинга");
using (var db = new dbModel(connection))
{
db.CommandTimeout = 1200000;
using (var tr = db.BeginTransaction())
{
try
{
ServiceLogger.Info("{info}", "таблица SS_FlInfo_Dupl перезапись начало");
db.AbonentInfoDelete();
ServiceLogger.Info("{info}", "таблица SS_FlInfo_Dupl перезапись конец");
ServiceLogger.Info("{info}", "таблица SS_FlInfo очищена");
ServiceLogger.Info("{info}", "таблица SS_FlInfo запись начало");
InsertBulk(list, db);
ServiceLogger.Info("{info}", "таблица SS_FlInfo запись окончание");
ServiceLogger.Info("{info}", "таблица SS_FlInfo обновление начало");
db.AbonentInfoUpdate();
ServiceLogger.Info("{info}", "таблица SS_FlInfo обновление конец");
tr.Commit();
ServiceLogger.Info("{info}", "импорт завершён");
return(list.Count);
}
catch (Exception e)
{
ServiceLogger.Error("{error}", e.ToString());
return(0);
}
}
}
}
catch (Exception e)
{
ServiceLogger.Error("{error}", e.ToString());
//string sd = @"�";
return(0);
}
}
}
/// <summary>
/// Вставляет список записей в таблицу
/// </summary>
/// <returns></returns>
private void InsertBulk(IEnumerable <SS_FlInfo> list, dbModel db)
{
try
{
db.BulkCopy(list);
}
catch (Exception e)
{
ServiceLogger.Error("{error}", e.ToString());
}
}
/// <summary>
/// Время ожидания запуска интеграции
/// </summary>
/// <param name="runTime"></param>
/// <returns></returns>
private int MilisecondsToWait(string runTime)
{
if (TimeSpan.TryParse(runTime, out TimeSpan _runTime))
{
return(MilisecondsToWait(_runTime));
}
string errorMessage = "ошибка определения времени выполнения";
ServiceLogger.Error("{error}", errorMessage);
throw new Exception(errorMessage);
}
/// <summary>
/// Returns the error view
/// </summary>
/// <param name="ex">The exception</param>
/// <param name="caller">The caller (optional, auto fill)</param>
/// <returns>The error message</returns>
private object ErrorView(Exception ex, [CallerMemberName] string caller = "")
{
ServiceLogger.Error(caller, ex);
var data = new
{
BaseData = GetBaseData(),
ex.Message
};
return(View["error.html", data]);
}
/// <summary>
/// Запуск
/// </summary>
/// <param name="args"></param>
protected override void OnStart(string[] args)
{
try
{
integrationWorker = new Thread(WannaKill);
integrationWorker.Start();
}
catch (Exception e)
{
ServiceLogger.Error("{work}", $"глобальная ошибка {e.ToString()}");
}
}
/// <summary>
/// На старт
/// </summary>
/// <param name="args"></param>
protected override void OnStart(string[] args)
{
try
{
serviceWorker = new Thread(DoBackups);
serviceWorker.Start();
}
catch (Exception e)
{
ServiceLogger.Info("{error}", "произошла ошибка");
ServiceLogger.Error("{error}", e.ToString());
}
}
public WebServiceResponse GetExcutableMethods()
{
var result = new WebServiceResponse();
result.Status = (int)0;// ErrorCodes.ALL_OK;
result.Message = "Success";
try
{
result.Items = Tasks.GetExcutableMethods().ToArray <object>();
}
catch (Exception ex)
{
result.Status = (int)1;// ErrorCodes.GENERAL_ERROR;
result.Message = ex.Message;
ServiceLogger.Error("ExecuteTask error: " + ex.Message);
}
return(result);
}
public void UnregisterConnectionStateListener(LoginSession session, String server)
{
try
{
IListServiceClient callback = _callbackCreator();
lock (_subscribersLock)
{
if (_subscribers.Exists(client => client.IsCurrentCallback(callback)))
{
_subscribers.Find(client => client.IsCurrentCallback(callback)).RemoveServer(server);
}
//_subscribers.RemoveAll(client => !client.HasCallbacks());
RemoveDeadClients();
}
}
catch (CommunicationException ex)
{
ServiceLogger.Error("Error while unregistering ConnectionStateListener", ex);
}
}
/// <summary>
/// The main entry point of the program
/// </summary>
/// <param name="args">The command line arguments</param>
private static void Main(string[] args)
{
try
{
if (args.Any(a => a.ContainsIgnoreCase("debug")))
{
var manager = new ServiceManager();
manager.Start();
Console.WriteLine("Press enter to exit.");
Console.ReadLine();
manager.Stop();
}
else
{
HostFactory.Run(c =>
{
c.Service <ServiceManager>(s =>
{
s.ConstructUsing(sf => new ServiceManager());
s.WhenStarted(sa => sa.Start());
s.WhenStopped(sa => sa.Stop());
});
c.UseNLog();
c.RunAsLocalSystem();
c.SetServiceName(Helper.Settings.Service.ServiceName);
c.SetDisplayName(Helper.Settings.Service.DisplayName);
c.SetDescription(Helper.Settings.Service.Description);
});
}
}
catch (Exception ex)
{
ServiceLogger.Error(
"An error has occured. Please check exception message for more information.",
ex);
Console.ReadLine();
}
}
public WebServiceResponse GetStatus()
{
var result = new WebServiceResponse();
result.Status = (int)0;// ErrorCodes.ALL_OK;
result.Message = "Success";
try
{
var Status = ServiceTasks.ServiceStatus;
// This does not work know types should be set up before service object creation
//WebServiceKnownTypesProvider.KnownTypes.Add(typeof(WebServiceStatus));
result.Item = Status;
}
catch (Exception ex)
{
result.Status = (int)1;// ErrorCodes.GENERAL_ERROR;
result.Message = ex.Message;
ServiceLogger.Error("ExecuteTask error: " + ex.Message);
}
return(result);
}
public bool RegisterConnectionStateListener(LoginSession session, String server)
{
try
{
IListServiceClient callback = _callbackCreator();
lock (_subscribersLock)
{
if (!_subscribers.Exists(client => client.IsCurrentCallback(callback)))
{
_subscribers.Add(new AsyncListServiceClient(callback));
}
_subscribers.Find(client => client.IsCurrentCallback(callback)).AddServer(server);
}
return(true);
}
catch (CommunicationException ex)
{
ServiceLogger.Error("Error while registering ConnectionStateListener", ex);
return(false);
}
}
public WebServiceResponse ExecuteTask(string TaskNames)
{
if (!string.IsNullOrEmpty(TaskNames))
{
TaskNames = TaskNames.Trim();
}
var result = new WebServiceResponse();
result.Status = (int)0;// ErrorCodes.ALL_OK;
result.Message = "Success";
try
{
ServiceTasks.DoTasks(TaskNames);
}
catch (Exception ex)
{
result.Status = (int)1;// ErrorCodes.GENERAL_ERROR;
result.Message = ex.Message;
ServiceLogger.Error("ExecuteTask error: " + ex.Message);
}
return(result);
}
/// <summary>
/// Создание backup-ов
/// </summary>
private void DoBackups()
{
ServiceLogger.Info("{thread}", "поехали");
while (enableService)
{
DateTime now = DateTime.Now;
if (!CheckFirstSaturdayOfMonth(now))
{
DateTime deltaTime = new DateTime(now.AddDays(1).Year,
now.AddDays(1).Month, now.AddDays(1).Day, 0, 0, 0);
Thread.Sleep(deltaTime.Subtract(now));
continue;
}
int executeWait = MilisecondsToWait(_params.StartTime);
int hoursWait = executeWait / 1000 / 60 / 60;
int minutesWait = (executeWait - (hoursWait * 60 * 60 * 1000)) / 1000 / 60;
int secWait = (executeWait - (hoursWait * 60 * 60 * 1000) - (minutesWait * 60 * 1000)) / 1000;
ServiceLogger.Info("{thread}", $"дата запуска: первая суббота месяца");
ServiceLogger.Info("{thread}", $"время запуска: {_params.StartTime}");
ServiceLogger.Info("{thread}", $"импорт будет выполнен через: " +
$"{hoursWait} час. {minutesWait} мин. {secWait} сек.");
Thread.Sleep(executeWait);
try
{
Launcher.Start(_params);
}
catch (Exception e)
{
ServiceLogger.Error("{error}", e.ToString());
}
// спать день
Thread.Sleep(86400000);
}
}
protected override void OnStart(string[] args)
{
try
{
//if (!SecureWebConfig.Secured)
//{
// SecureWebConfig.Secure();
//}
}
catch (Exception ex)
{
ServiceLogger.Error("Configuration cannot be read, reason: " + ex.Message);
}
ServiceTasks.LoadConfig();
// collect and pass back the list of known types
WebServiceKnownTypesProvider.KnownTypes.Add(typeof(WebServiceStatus));
oServiceHost = new ServiceHost(oServiceType);
try
{
if (oServiceHost.BaseAddresses.Count == 0)
{
string ba = DefaultHTTPUrl; //ExtensionHelpers.GetConfigString("WebServiceBaseURL");
if (string.IsNullOrEmpty(ba))
{
if (UseHTTPS)
{
ba = DefaultHTTPSUrl;
}
else
{
ba = DefaultHTTPUrl;
}
}
else
{
if (ba.Contains("http://"))
{
UseHTTPS = false;
}
}
var baseAddresses = new Uri[] { new Uri(ba) };
oServiceHost = new ServiceHost(oServiceType, baseAddresses);
var endpoint = CreateEndpoint(oServiceInterfaceType, ba);
oServiceHost.AddServiceEndpoint(endpoint);
ServiceMetadataBehavior metadataBehavior = new ServiceMetadataBehavior();
//metadataBehavior.HttpGetEnabled = true;
oServiceHost.Description.Behaviors.Add(metadataBehavior);
}
oServiceHost.Authorization.ServiceAuthorizationManager = new RestAuthorizationManager();
oServiceHost.Open();
}
catch (Exception ex)
{
ServiceLogger.Error("Service cannot be started, reason: " + ex.Message);
return;
}
//Tasks.StartTimer();
StartHTTPCompanionService(oServiceHost.BaseAddresses[0].ToString());
ServiceLogger.Info("SERVICE STARTED");
foreach (var uri in oServiceHost.BaseAddresses)
{
ServiceLogger.Info("Listening on: " + uri);
}
}
