private void SearchActiveSessions(LogFileParser.foundElementInfo [] selectedUserPCs, string selectedUser)
{
ITerminalServicesManager manager = new TerminalServicesManager();
for (int i = 0; i < selectedUserPCs.Length; i++)
{
try {
Ping ping = new Ping();
PingOptions pingOptions = new PingOptions();
pingOptions.DontFragment = true;
string data = "fff";
byte[] buffer = Encoding.ASCII.GetBytes(data);
PingReply reply = ping.Send(selectedUserPCs[i].name, 120, buffer, pingOptions);
if (reply.Status == IPStatus.Success)
{
using (ITerminalServer server = manager.GetRemoteServer(selectedUserPCs[i].name)) {
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
if (session.UserName.ToLower() == selectedUser.ToLower() && session.ConnectionState == ConnectionState.Active)
{
selectedUserPCs[i].name = "->" + selectedUserPCs[i].name + "<-";
}
}
}
}
} catch { }
}
}
private void ValidateSessionsAsync()
{
ThreadPool.QueueUserWorkItem(async(object o) =>
{
ITerminalServicesManager manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetLocalServer())
{
server.Open();
var localSessions = server.GetSessions().Where(s => s.SessionId > 0 && (s.ConnectionState == Cassia.ConnectionState.Active));
var messages = await _msgReader.GetAllMessages();
if (messages.Count(m => m.Command.Type == WinGuard.Domain.Enumaretions.ClientCommandType.LOGOUT) > 0 &&
localSessions.Any(s => messages.Any(m => m.Command.ClientIdentifier == s.SessionId.ToString())))
{
foreach (var session in localSessions.Where(s => messages.Any(m => m.Command.ClientIdentifier == s.SessionId.ToString())))
{
session.Logoff();
}
return;
}
foreach (ITerminalServicesSession session in localSessions)
{
await _authService.Login(_encryptService.EncryptMessage(session.SessionId.ToString()),
_encryptService.EncryptMessage(session.UserName));
}
}
});
}
public Response GetUserSesssions()
{
var response = new Response();
try
{
var manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetLocalServer())
{
server.Open();
var sessions = server.GetSessions()
.Where(s => !string.IsNullOrEmpty(s.UserName))
.Select(s => new
{
User = s.DomainName + @"\" + s.UserName,
LoginDate = s.LoginTime?.ToString("g"),
State = s.ConnectionState.ToString()
});
response.Data = sessions;
return(response);
}
}
catch (Exception ex)
{
Log.Error(ex.Message);
response.Status = Status.Error;
response.Notifications.Add(new Notification
{
Message = ex.Message,
MessageDetail = ex.StackTrace,
Status = Status.Error
});
return(response);
}
}
public static List <ITerminalServicesSession> GetList()
{
List <ITerminalServicesSession> session_list = new List <ITerminalServicesSession>();
ITerminalServicesManager manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetLocalServer())
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
// skip the SYSTEM session
if (session.SessionId == 0)
{
continue;
}
// if there is no username the session is special accounts
if (session.UserName == String.Empty)
{
continue;
}
session_list.Add(session);
}
}
return(session_list);
}
private static int GetUserSessionId(string username)
{
try
{
ITerminalServicesManager manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetLocalServer())
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
NTAccount account = session.UserAccount;
if (account == null)
{
continue;
}
var userName = account.Value.Split('\\')[1];
if (userName.ToLower().Equals(username.ToLower()))
{
return(session.SessionId);
}
}
}
return(-1);
}
catch (Exception)
{
return(-1);
}
}
/// <overloads><inheritdoc /></overloads>
/// <inheritdoc />
public IList <ITerminalServicesSession> GetSessions(string serverName)
{
using (ITerminalServer server = GetRemoteServer(serverName))
{
server.Open();
return(server.GetSessions());
}
}
/// <inheritdoc />
public IList <ITerminalServicesSession> GetSessions()
{
using (ITerminalServer server = GetLocalServer())
{
server.Open();
return(server.GetSessions());
}
}
static void CheckBackupTime(object sender, System.Timers.ElapsedEventArgs e)
{
if ((int)DateTime.Now.DayOfWeek != Settings.Default.backupday)
{
return;
}
backupTime = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, (int)Settings.Default.backuphour, (int)Settings.Default.backupminute, 0);
if (backupTime > DateTime.Now)
{
if ((int)(backupTime - DateTime.Now).TotalMinutes <= Settings.Default.startcheck)
{
foreach (var session in activeusers)
{
if (!Notifications.ContainsKey(session.SessionId))
{
SendMessage(session.SessionId, Settings.Default.alert1box.Replace("{time}", backupTime.ToString("HH:mm")));
Notifications.Add(session.SessionId, DateTime.Now);
}
else
{
if ((DateTime.Now - Notifications[session.SessionId]).TotalMinutes >= (int)Settings.Default.alert_interval)
{
SendMessage(session.SessionId, Settings.Default.alert1box.Replace("{time}", backupTime.ToString("HH:mm")));
Notifications[session.SessionId] = DateTime.Now;
}
}
}
}
}
else
{
if (backupTime < startuptime)
{
FinishedBackups.Add(backupTime);
return;
}
if (!FinishedBackups.Contains(backupTime))
{
ITerminalServicesManager manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetLocalServer())
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
KillParusWithNotifiction(session);
}
}
if (Settings.Default.backupauto && Application.OpenForms.OfType <BackupWindow>().Count() == 0)
{
bwindow = new BackupWindow();
bwindow.ShowDialog();
}
}
}
}
/// <summary>
/// Register all active sessions on server(s)
/// </summary>
public void RegisterSessions()
{
if (!checkProgramActivityTimer.Enabled)
{
checkProgramActivityTimer.Start();
}
if (!troubleShootingTimer.Enabled)
{
troubleShootingTimer.Start();
}
activeSessions = new List <ActiveSession>();
for (int i = LogonTracerConfig.Instance.ServersToTrace.Count() - 1; i > -1; i--)
{
string serverName = LogonTracerConfig.Instance.ServersToTrace[i];
try
{
using (ITerminalServer server = manager.GetRemoteServer(serverName))
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
ActiveSession activeSession = null;
if (session.UserAccount == null || session.ConnectionState != Cassia.ConnectionState.Active)
{
continue;
}
activeSession = repoProvider.BuildSession(session);
activeSessions.Add(activeSession);
if (activeSession.DbId.HasValue && LogonTracerConfig.Instance.LogSessionHistory)
{
repoProvider.UpdateSessionHistory(activeSession.DbId.Value, SessionUpdateDetails.StateUpdated, new Dictionary <string, string>
{
{ "Old value", SessionState.ServiceDown.ToString() },
{ "New value", SessionState.Active.ToString() }
});
}
repoProvider.SaveSession(activeSession);
}
}
}
catch (Win32Exception ex)
{
LoggingUtils.DefaultLogger.AddLogMessage(this, MessageType.Error, "Error while trying access the server. Check Remote Desktop Services Permissions for this server and try again. Server:{0}. Message: {1}", serverName, ex.Message);
LogonTracerConfig.Instance.ServersToTrace = LogonTracerConfig.Instance.ServersToTrace.Where(stt => stt != serverName).ToArray();
}
catch (Exception ex)
{
LoggingUtils.DefaultLogger.AddLogMessage(this, MessageType.Error, "Type: {0}. Server:{1}. Message: {2}", ex.GetType(), serverName, ex.Message);
}
}
inputActivityTimer.Start();
sessionStateUpdateTimer.Start();
checkRepositoryTimer.Start();
}
/// <summary>
/// Logouts all currently s
/// </summary>
public static void LogoutUsers()
{
using (ITerminalServer server = _manager.GetLocalServer())
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
if (session.SessionId != 0)
{
session.Logoff();
}
}
}
}
private static void ListSessions(string[] args)
{
if (args.Length < 2)
{
Console.WriteLine("Usage: SessionInfo listsessions [server]");
return;
}
using (ITerminalServer server = GetServerFromName(args[1]))
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
WriteSessionInfo(session);
}
}
}
private void LoadTSUsers()
{
try
{
listTSUser.Clear();
TerminalServicesManager tsManager = new TerminalServicesManager();
string[] massHosts = new string[] { "TS1", "TS2", "TS3", "TS4", "TS5", "TS6", "TS7" };
foreach (var host in massHosts)
{
using (ITerminalServer server = tsManager.GetRemoteServer(host))
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
NTAccount account = session.UserAccount;
if (account != null)
{
TSUser user = new TSUser()
{
DomainName = session.DomainName,
PCName = session.ClientName,
TSName = host,
UserName = session.UserName,
ConnectionState = session.ConnectionState.ToString(),
WindowStationName = session.WindowStationName,
UserAccount = account.ToString(),
};
Dispatcher.Invoke((Action)(() =>
{
listTSUser.Add(user);
}));
}
}
}
}
foreach (var user in listTSUser)
{
user.ClientIPAddress = (from i in listPcIPAndPcName where i.PcName.ToLower() == user.PCName.ToLower() select i.PcIP).FirstOrDefault();
}
}
catch (Exception ex)
{
Bindings.StatusBarText = ex.Message;
}
}
public static void Main(string[] args)
{
ITerminalServicesManager manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetRemoteServer("your-server-name"))
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
NTAccount account = session.UserAccount;
if (account != null)
{
Console.WriteLine(account);
}
}
}
}
public static bool SendMessage(string message)
{
ITerminalServicesManager manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetRemoteServer(ServerIPAddress))
{
server.Open();
var session = server.GetSessions().Where(x => x.UserName == UserNameOnServer).FirstOrDefault();
if (session != null)
{
var response = session.MessageBox(message, "Message for user", RemoteMessageBoxButtons.YesNo,
RemoteMessageBoxIcon.Question, RemoteMessageBoxDefaultButton.Button2, RemoteMessageBoxOptions.None, TimeSpan.Zero, true);
return(response == RemoteMessageBoxResult.Yes);
}
}
return(false);
}
private static ITerminalServicesSession GetSession()
{
ITerminalServicesManager manager = new TerminalServicesManager();
ITerminalServicesSession session;
using (ITerminalServer server = manager.GetRemoteServer("192.168.0.10"))
{
server.Open();
int i = 0;
IList <ITerminalServicesSession> sessionsList = server.GetSessions();
do
{
session = sessionsList[i];
i++;
} while (i < sessionsList.Count && session.UserName.ToUpper() != "MEDIA SERVER");
}
return(session.UserName.ToUpper() == "MEDIA SERVER" && session != null ? session : null);
}
private void disconnectUSER(string user)
{
try
{
foreach (ITerminalServicesSession session in server.GetSessions())
{
if (session.UserName == user)
{
session.Disconnect();
session.Logoff();
Console.WriteLine("-Cerrando Sesión Usuario: " + user);
}
}
}
catch (Exception)
{
Console.WriteLine("[Error] ha surgido un problema durante el cierre de sesión de un usuario.");
}
}
//Возвращает список сеансов с сервера(имя сервера в качестве параметра)
public void getSessionList()
{
IList <ITerminalServicesSession> serverSession;
int countSession = 0;
serverSessionList.Clear();
//Далее идет код для подключения к серверу
ITerminalServicesManager manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetRemoteServer(serverName))
{
server.Open();
// Перебираем все сеансы на сервере.
try
{
serverSession = server.GetSessions();
}
catch (Exception ex)
{
serverStatus = ex.Message;
serverSession = null;
log.appendLog(MethodBase.GetCurrentMethod().ReflectedType.Name + "\n" + MethodBase.GetCurrentMethod().Name + "\n" + ex + "\n" + Application.UserAppDataPath);
}
server.Close();
if (serverSession != null)
{
foreach (ITerminalServicesSession session in serverSession)
{
//Фильтруем системный сеанс с Id 0. Отбираем сеансы в статусе Active или в статусе Disconnected, но не с пустым именем
if (session.SessionId != 0 && ((session.ConnectionState == ConnectionState.Active) || (session.ConnectionState == ConnectionState.Disconnected && session.UserName != "")))
{
serverSessionList.Add(session);
countSession++;
}
}
}
}
sessionCount = countSession;
lastCheck = DateTime.Now.ToString();
}
private static int CountUsers()
{
int NbrUsers = 0;
ITerminalServicesManager manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetRemoteServer(Settings.Ip))
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
NTAccount account = session.UserAccount;
if (account != null)
{
NbrUsers++;
}
}
}
return(NbrUsers);
}
static void Main(string[] args)
{
using (ITerminalServer server = manager.GetLocalServer()) {
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
if (session.UserAccount == null || session.SessionId == 0)
{
continue; // Don't touch system session
}
if (session.SessionId == manager.CurrentSession.SessionId)
{
continue; // Don't touch current session
}
session.Logoff();
}
}
}
/// <summary>
/// Find session among all servers and sessions
/// </summary>
/// <param name="activeSession">Registered session</param>
/// <returns>Session</returns>
private ITerminalServicesSession FindSession(ActiveSession activeSession)
{
ITerminalServicesSession foundedSession = null;
foreach (string serverName in LogonTracerConfig.Instance.ServersToTrace)
{
try
{
using (ITerminalServer server = manager.GetRemoteServer(serverName))
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
if (session.UserAccount == null)
{
continue;
}
if (activeSessions.Where(acs => acs.MachineName == session.Server.ServerName &&
acs.UserName == session.UserName &&
/*AppData.DateTimeConvertUtils.Compare(acs.SessionBegin.Value, session.ConnectTime.Value) == 1*/ acs.SessionBegin.Value == session.ConnectTime.Value).Count() == 0 &&
session.ConnectionState != Cassia.ConnectionState.Disconnected)
{
ActiveSession newSession = repoProvider.BuildSession(session);
activeSessions.Add(newSession);
repoProvider.SaveSession(newSession);
continue;
}
if (session.UserName == activeSession.UserName && session.Server.ServerName == activeSession.MachineName)
{
foundedSession = session;
}
}
}
}
catch (Exception ex)
{
LoggingUtils.DefaultLogger.AddLogMessage(this, MessageType.Error, "Type: {0}. Server{1}. Message: {2}", ex.GetType(), serverName, ex.Message);
}
}
return(foundedSession);
}
/// <summary>
/// Overrides the <see cref="Execute"/> method exposed by the <see cref="SwedishCodeActivity{T}"/> class.
/// </summary>
/// <param name="context">The execution context passed when invoked.</param>
/// <returns>A string back to the caller.</returns>
/// <inheritdoc cref="SwedishCodeActivity{T}"/>
protected override object Execute(CodeActivityContext context)
{
ITerminalServicesManager iTerminalServicesManager = new TerminalServicesManager();
StringBuilder newStringBuilder = new StringBuilder();
using (ITerminalServer server = iTerminalServicesManager.GetRemoteServer(Environment.MachineName))
{
server.Open();
IList <ITerminalServicesSession> newSessionsList = server.GetSessions();
Parallel.ForEach(
newSessionsList,
s =>
{
if (!string.IsNullOrWhiteSpace(s.UserName))
{
newStringBuilder.AppendLine($"Session: {s.SessionId} UserName: {s.UserName} LogonTime: {s.LoginTime} IdleTime: {s.IdleTime}");
}
});
}
return(newStringBuilder.ToString());
}
static void UpdateUsers(object sender, System.Timers.ElapsedEventArgs e)
{
activeusers.Clear();
ITerminalServicesManager manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetLocalServer())
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
if (ParusRunned(session.GetProcesses()))
{
activeusers.Add(session);
}
}
}
if (uwindow != null)
{
try { uwindow.UpdateList(); }
catch { }
}
}
public PluginOutputCollection Output()
{
ITerminalServicesManager manager = new TerminalServicesManager();
List <SimplePluginOutput> listSPO = new List <SimplePluginOutput>();
_pluginOutputs.PluginOutputList.Clear();
using (ITerminalServer server = manager.GetRemoteServer(Environment.MachineName.ToString()))
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
NTAccount account = session.UserAccount;
if (account != null)
{
listSPO.Add(new SimplePluginOutput(account.ToString(), false));
_pluginOutputs.PluginOutputList.Add(new PluginOutput("User", listSPO));
}
}
}
return(_pluginOutputs);
}
public Response DropUserSession([FromBody] string username)
{
var response = new Response();
try
{
Log.Debug($"DropUserSession called for user {username}.");
var manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetLocalServer())
{
server.Open();
var userSession = server.GetSessions()
.FirstOrDefault(s => string.Equals($@"{s.DomainName}\{s.UserName}", username, StringComparison.InvariantCultureIgnoreCase));
if (userSession == null)
{
response.Status = Status.Error;
response.AddErrorNotification($"User session for {username} not found.");
return(response);
}
userSession.Logoff(true);
}
var message = $"Successfully closed session for user {username}.";
Log.Debug(message);
response.AddSuccessNotification(message);
return(response);
}
catch (Exception ex)
{
Log.Error(ex.Message);
response.Status = Status.Error;
response.AddErrorNotification(ex.Message, ex.StackTrace);
return(response);
}
}
static void LogUserOut(string computerId)
{
using (ITerminalServer server = manager.GetRemoteServer(computerId))
{
if (!server.IsOpen) // check to see if RPC is enabled.
{
return;
}
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
// Example snipit
//Console.WriteLine("Hi there, " + session.UserAccount + " on session " + session.SessionId);
//Console.WriteLine("It looks like you logged on at " + session.LoginTime + " and are now " + session.ConnectionState);
if (server.IsOpen) // check if server is up
{
if (session.UserAccount != null) // skip any windows accounts
{
try // try to disconnect sessions
{
session.Disconnect();
Console.WriteLine("Logged the user out.");
}
catch (Exception e)
{
Console.WriteLine("General failure.");
}
}
}
else
{
Console.WriteLine("Could not ping server.");
}
}
}
}
static void Main(string[] args)
{
ITerminalServicesManager manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetLocalServer())
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
//Console.WriteLine(session.UserAccount.Value);
if (session.UserName == Environment.UserName)
{
Console.WriteLine(session.UserAccount + " on session " + session.SessionId + " ip address " + session.ClientIPAddress);
//Console.WriteLine("It looks like you logged on at " + session.LoginTime + " and are now " + session.ConnectionState);
}
}
}
Console.ReadKey();
}
public static bool ServerIsBusy()
{
ITerminalServicesManager manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetRemoteServer(ServerIPAddress))
{
server.Open();
var session = server.GetSessions().Where(x => x.UserName == UserNameOnServer).FirstOrDefault();
if (session != null)
{
ClientName = session.ClientName;
ClientIPAddress = session.ClientIPAddress?.ToString();
IdleTime = session.IdleTime;
ClearMemory();
return(session.ConnectionState == ConnectionState.Active);
}
else
{
return(false);
}
}
}
private ITerminalServicesSession[] GetUsers(string szMachine, string szUsername, CancellationToken _cancel)
{
bool _exceptionThrown = false;
//List<CimInstance> _results = new List<CimInstance>();
List <ITerminalServicesSession> _results = new List <ITerminalServicesSession>();
if (!_cancel.IsCancellationRequested)
{
try
{
ITerminalServicesManager _tManager = new TerminalServicesManager();
using (ITerminalServer _tServer = _tManager.GetRemoteServer(szMachine))
{
_tServer.Open();
foreach (ITerminalServicesSession _sesh in _tServer.GetSessions())
{
if (_cancel.IsCancellationRequested)
{
break;
}
if (_sesh.UserName.ToLower().Contains(szUsername.ToLower()))
{
_results.Add(_sesh);
}
}
}
}
catch (Win32Exception _w32)
{
switch (_w32.HResult)
{
case unchecked ((int)0x80004005):
Status($"Error Gathering Logged On Users ({szMachine}) - most likely offline / firewall");
break;
default:
if (System.Diagnostics.Debugger.IsAttached)
{
System.Diagnostics.Debugger.Break();
}
Status($"Error Gathering Logged On Users ({szMachine}) - PROVIDE TO SUPPORT - W32 UNKNKOWN ({_w32.HResult})");
break;
}
_exceptionThrown = true;
}
catch (Exception _ex)
{
if (System.Diagnostics.Debugger.IsAttached)
{
System.Diagnostics.Debugger.Break();
}
Status($"Error Gathering Logged On Users ({szMachine}) - PROVIDE TO SUPPORT - UNKNKOWN ({_ex.GetType().Name}:{_ex.HResult})");
_exceptionThrown = true;
}
if (_exceptionThrown)
{
_results.Clear(); // clear results so we do not error and can continue.
System.Threading.Thread.Sleep(5000); // give them time to see the error
}
}
return(_results.ToArray());
}
private void ZabbixSender()
{
List <User> userList = new List <User>();
Sender sender = new Sender(Settings.ZabbixServer, Settings.ZabbixPort);
while (!ЗавершениеРаботы)
{
bool errorExist = false;
userList.Clear();
#region Сбор состояний пользователей
using (ITerminalServer server = Settings.manager.GetLocalServer())
{
try
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
try
{
if (session.UserAccount == null)
{
continue;
}
if (Settings.IgnoreUsername.Contains(session.UserAccount.ToString()))
{
continue;
}
int state = 0;
double idle = Math.Floor(session.IdleTime.TotalSeconds);
if (session.ConnectionState == Cassia.ConnectionState.Active || session.ConnectionState == Cassia.ConnectionState.Idle)
{
if (idle < Settings.IdleTime)
{
state = 2;
}
else
{
state = 1;
}
}
userList.Add(new User(session.UserAccount.ToString(), state));
}
catch (Exception ex)
{
Settings.logger.Error(ex, "Ошибка чтения состояния пользователя:");
}
}
}
catch (Exception ex)
{
Settings.logger.Error(ex, "Ошибка чтения списка пользователей:");
}
}
#endregion
foreach (User usr in userList)
{
Settings.logger.Debug("{0} = {1}", usr.Username, usr.Condition);
}
Settings.logger.Debug("Отправка данных в zabbix");
foreach (ZabbixUser zabbix_usr in Settings.list)
{
User usr = userList.Find(x => x.Equals(zabbix_usr.Username));
if (usr == null)
{
Settings.logger.Debug("{1} = {2}", zabbix_usr.ZabbixUsername, 0);
string send = String.Format("user.work[{0},{1}]", zabbix_usr.ZabbixUsername, Settings.ZabbixParam);
try
{
SenderResponse response = sender.Send(Settings.ZabbixNodename, send, "0");
Settings.logger.Debug(send);
Settings.logger.Debug(response.Response);
Settings.logger.Debug(response.Info);
}
catch (Exception ex)
{
Settings.logger.Error(ex, "Ошибка отправки данных в zabbix:");
errorExist = true;
}
}
else
{
Settings.logger.Debug("{0}({1}) = {2}", usr.Username, zabbix_usr.ZabbixUsername, usr.Condition);
string send = String.Format("user.work[{0},{1}]", zabbix_usr.ZabbixUsername, Settings.ZabbixParam);
try
{
SenderResponse response = sender.Send(Settings.ZabbixNodename, send, usr.Condition.ToString());
Settings.logger.Debug(send);
Settings.logger.Debug(response.Response);
Settings.logger.Debug(response.Info);
}
catch (Exception ex)
{
Settings.logger.Error(ex, "Ошибка отправки данных в zabbix:");
errorExist = true;
}
}
}
#region подсчет количества
int _CountSummary = userList.Count;
int _CountActive = 0;
int _CountIdle = 0;
int _CountOffline = 0;
foreach (User usr in userList)
{
if (usr.Condition == 2)
{
_CountActive++;
}
if (usr.Condition == 1)
{
_CountIdle++;
}
if (usr.Condition == 0)
{
_CountOffline++;
}
}
#endregion
#region Отправка количества итого
if (Settings.SendSummary)
{
string send = String.Format("user.work[{0},{1}]", "Summary", Settings.ZabbixParam);
try
{
if (!errorExist)
{
SenderResponse response = sender.Send(Settings.ZabbixNodename, send, _CountSummary.ToString());
Settings.logger.Debug(send);
Settings.logger.Debug(response.Response);
Settings.logger.Debug(response.Info);
}
}
catch (Exception ex)
{
Settings.logger.Error(ex, "Ошибка отправки данных в zabbix:");
errorExist = true;
}
}
#endregion
#region Отправка количества активных
if (Settings.SendActive)
{
string send = String.Format("user.work[{0},{1}]", "Active", Settings.ZabbixParam);
try
{
if (!errorExist)
{
SenderResponse response = sender.Send(Settings.ZabbixNodename, send, _CountActive.ToString());
Settings.logger.Debug(send);
Settings.logger.Debug(response.Response);
Settings.logger.Debug(response.Info);
}
}
catch (Exception ex)
{
Settings.logger.Error(ex, "Ошибка отправки данных в zabbix:");
errorExist = true;
}
}
#endregion
#region Отправка количества отсутствующих
if (Settings.SendIdle)
{
string send = String.Format("user.work[{0},{1}]", "Idle", Settings.ZabbixParam);
try
{
if (!errorExist)
{
SenderResponse response = sender.Send(Settings.ZabbixNodename, send, _CountIdle.ToString());
Settings.logger.Debug(send);
Settings.logger.Debug(response.Response);
Settings.logger.Debug(response.Info);
}
}
catch (Exception ex)
{
Settings.logger.Error(ex, "Ошибка отправки данных в zabbix:");
errorExist = true;
}
}
#endregion
#region Отправка количества отключенных
if (Settings.SendOffline)
{
string send = String.Format("user.work[{0},{1}]", "Offline", Settings.ZabbixParam);
try
{
if (!errorExist)
{
SenderResponse response = sender.Send(Settings.ZabbixNodename, send, _CountOffline.ToString());
Settings.logger.Debug(send);
Settings.logger.Debug(response.Response);
Settings.logger.Debug(response.Info);
}
}
catch (Exception ex)
{
Settings.logger.Error(ex, "Ошибка отправки данных в zabbix:");
errorExist = true;
}
}
#endregion
Settings.logger.Debug("Окончание отправки данных в zabbix");
for (int i = 0; (i <= Settings.Delay && !ЗавершениеРаботы); i += 1000)
{
Thread.Sleep(1000);
}
}
}
protected override void OnStart(string[] args)
{
Settings.Init();
Settings.logger.Info("Попытка запуска службы");
bool iniError = false;
IniFile INI = new IniFile(Settings.WorkDirectory + "\\config.ini");
if (!INI.KeyExists("ZabbixServer", "General"))
{
INI.Write("General", "ZabbixServer", "192.168.0.1"); iniError = true;
}
if (!INI.KeyExists("ZabbixPort", "General"))
{
INI.Write("General", "ZabbixPort", "10051"); iniError = true;
}
if (!INI.KeyExists("ZabbixNodename", "General"))
{
INI.Write("General", "ZabbixNodename", "all"); iniError = true;
}
if (!INI.KeyExists("ZabbixParam", "General"))
{
INI.Write("General", "ZabbixParam", "workcomp"); iniError = true;
}
if (!INI.KeyExists("Delay", "General"))
{
INI.Write("General", "Delay", "300"); iniError = true;
}
if (!INI.KeyExists("IdleTime", "General"))
{
INI.Write("General", "IdleTime", "300"); iniError = true;
}
if (!INI.KeyExists("SendSummary", "General"))
{
INI.Write("General", "SendSummary", "1"); iniError = true;
}
if (!INI.KeyExists("SendActive", "General"))
{
INI.Write("General", "SendActive", "1"); iniError = true;
}
if (!INI.KeyExists("SendIdle", "General"))
{
INI.Write("General", "SendIdle", "1"); iniError = true;
}
if (!INI.KeyExists("SendOffline", "General"))
{
INI.Write("General", "SendOffline", "1"); iniError = true;
}
if (!INI.KeyExists("IgnoreUsername", "General"))
{
INI.Write("General", "IgnoreUsername", "HOSTNAME/USERNAME1,HOSTNAME/USERNAME2"); iniError = true;
}
if (iniError)
{
Settings.logger.Info("Отсутствутю обязательные параметры в конфиг файле(пример записаны в конфиг)");
Environment.Exit(0);
}
else
{
Settings.ZabbixServer = INI.ReadINI("General", "ZabbixServer");
Settings.ZabbixPort = Convert.ToInt32(INI.ReadINI("General", "ZabbixPort"));
Settings.ZabbixNodename = INI.ReadINI("General", "ZabbixNodename");
Settings.ZabbixParam = INI.ReadINI("General", "ZabbixParam");
Settings.Delay = 1000 * Convert.ToInt32(INI.ReadINI("General", "Delay"));
Settings.IdleTime = Convert.ToInt32(INI.ReadINI("General", "IdleTime"));
Settings.SendSummary = INI.ReadINI("General", "SendSummary") == "1" ? true : false;
Settings.SendActive = INI.ReadINI("General", "SendActive") == "1" ? true : false;
Settings.SendIdle = INI.ReadINI("General", "SendIdle") == "1" ? true : false;
Settings.SendOffline = INI.ReadINI("General", "SendOffline") == "1" ? true : false;
Settings.IgnoreUsername = INI.ReadINI("General", "IgnoreUsername").Split(',').ToList();
}
#region Печать всех пользователей в лог файл
Settings.logger.Info("*********************************");
Settings.logger.Info("Список всех пользователей:");
using (ITerminalServer server = Settings.manager.GetLocalServer())
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
if (session.UserAccount == null)
{
continue;
}
Settings.logger.Info(" {0}:", session.UserAccount);
}
}
Settings.logger.Info("*********************************");
Settings.logger.Info("");
#endregion
#region Чтение списка отправляемх пользователей
int UserCount = 0;
while (true)
{
UserCount++;
String _username = INI.ReadINI("User" + UserCount, "Username");
String _zabbix_username = INI.ReadINI("User" + UserCount, "ZabbixUsername");
if (_username.Trim().Length == 0 || _zabbix_username.Trim().Length == 0)
{
UserCount--;
break;
}
Settings.list.Add(new ZabbixUser(_username, _zabbix_username));
}
if (UserCount == 0)
{
Settings.logger.Info("Отсутствутю обязательное перечисление пользователей в конфиг файле(пример записан в конфиг)");
INI.Write("User1", "Username", "home-pc\\myusername");
INI.Write("User1", "ZabbixUsername", "zab-user1");
Environment.Exit(0);
}
Settings.logger.Info("*********************************");
Settings.logger.Info("Будут отправляться сведения по следующим пользователям:");
foreach (ZabbixUser _user in Settings.list)
{
Settings.logger.Info(" {0}", _user.ToString());
}
Settings.logger.Info("*********************************");
Settings.logger.Info("");
#endregion
thr = new ServiceThread();
Settings.logger.Info("Служба успешно запущена");
}
