1026 lines
33 KiB
C#
1026 lines
33 KiB
C#
// Copyright (c) 2012, Outercurve Foundation.
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification,
|
|
// are permitted provided that the following conditions are met:
|
|
//
|
|
// - Redistributions of source code must retain the above copyright notice, this
|
|
// list of conditions and the following disclaimer.
|
|
//
|
|
// - Redistributions in binary form must reproduce the above copyright notice,
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
// and/or other materials provided with the distribution.
|
|
//
|
|
// - Neither the name of the Outercurve Foundation nor the names of its
|
|
// contributors may be used to endorse or promote products derived from this
|
|
// software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
|
|
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Data;
|
|
using System.Security;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using System.Threading;
|
|
using System.Web;
|
|
using System.Diagnostics;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Web.Services;
|
|
using System.Web.Services.Protocols;
|
|
using System.ComponentModel;
|
|
using System.ServiceProcess;
|
|
using System.ServiceModel;
|
|
using System.Runtime.Remoting;
|
|
using System.Runtime.Remoting.Channels;
|
|
using System.Runtime.Remoting.Channels.Tcp;
|
|
using System.Management;
|
|
using System.Collections.Specialized;
|
|
using Microsoft.Web.PlatformInstaller;
|
|
using Microsoft.Web.Services3;
|
|
using Microsoft.Win32;
|
|
using WebsitePanel.Providers.Utils;
|
|
using WebsitePanel.Server.Code;
|
|
using WebsitePanel.Server.Utils;
|
|
using WebsitePanel.Providers;
|
|
using WebsitePanel.Server.WPIService;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
namespace WebsitePanel.Server
|
|
{
|
|
/// <summary>
|
|
/// Summary description for WindowsServer
|
|
/// </summary>
|
|
[WebService(Namespace = "http://smbsaas/websitepanel/server/")]
|
|
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
|
|
[Policy("ServerPolicy")]
|
|
[ToolboxItem(false)]
|
|
public class WindowsServer : System.Web.Services.WebService
|
|
{
|
|
#region Terminal connections
|
|
[WebMethod]
|
|
public TerminalSession[] GetTerminalServicesSessions()
|
|
{
|
|
try
|
|
{
|
|
Log.WriteStart("GetTerminalServicesSessions");
|
|
List<TerminalSession> sessions = new List<TerminalSession>();
|
|
string ret = FileUtils.ExecuteSystemCommand("qwinsta", "");
|
|
|
|
// parse returned string
|
|
StringReader reader = new StringReader(ret);
|
|
string line = null;
|
|
int lineIndex = 0;
|
|
while ((line = reader.ReadLine()) != null)
|
|
{
|
|
/*if (line.IndexOf("USERNAME") != -1 )
|
|
continue;*/
|
|
//
|
|
if (lineIndex == 0)
|
|
{
|
|
lineIndex++;
|
|
continue;
|
|
}
|
|
|
|
Regex re = new Regex(@"(\S+)\s+", RegexOptions.Multiline | RegexOptions.IgnoreCase);
|
|
MatchCollection matches = re.Matches(line);
|
|
|
|
// add row to the table
|
|
string username = "";
|
|
if (matches.Count > 4)
|
|
username = matches[1].Value.Trim();
|
|
|
|
if (username != "")
|
|
{
|
|
TerminalSession session = new TerminalSession();
|
|
//
|
|
session.SessionId = Int32.Parse(matches[2].Value.Trim());
|
|
session.Username = username;
|
|
session.Status = matches[3].Value.Trim();
|
|
|
|
sessions.Add(session);
|
|
}
|
|
//
|
|
lineIndex++;
|
|
}
|
|
reader.Close();
|
|
|
|
Log.WriteEnd("GetTerminalServicesSessions");
|
|
return sessions.ToArray();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.WriteError("GetTerminalServicesSessions", ex);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
[WebMethod]
|
|
public void CloseTerminalServicesSession(int sessionId)
|
|
{
|
|
try
|
|
{
|
|
Log.WriteStart("CloseTerminalServicesSession");
|
|
FileUtils.ExecuteSystemCommand("rwinsta", sessionId.ToString());
|
|
Log.WriteEnd("CloseTerminalServicesSession");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.WriteError("CloseTerminalServicesSession", ex);
|
|
throw;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Windows Processes
|
|
[WebMethod]
|
|
public WindowsProcess[] GetWindowsProcesses()
|
|
{
|
|
try
|
|
{
|
|
Log.WriteStart("GetWindowsProcesses");
|
|
|
|
List<WindowsProcess> winProcesses = new List<WindowsProcess>();
|
|
|
|
WmiHelper wmi = new WmiHelper("root\\cimv2");
|
|
ManagementObjectCollection objProcesses = wmi.ExecuteQuery(
|
|
"SELECT * FROM Win32_Process");
|
|
|
|
foreach (ManagementObject objProcess in objProcesses)
|
|
{
|
|
int pid = Int32.Parse(objProcess["ProcessID"].ToString());
|
|
string name = objProcess["Name"].ToString();
|
|
|
|
// get user info
|
|
string[] methodParams = new String[2];
|
|
objProcess.InvokeMethod("GetOwner", (object[])methodParams);
|
|
string username = methodParams[0];
|
|
|
|
WindowsProcess winProcess = new WindowsProcess();
|
|
winProcess.Pid = pid;
|
|
winProcess.Name = name;
|
|
winProcess.Username = username;
|
|
winProcess.MemUsage = Int64.Parse(objProcess["WorkingSetSize"].ToString());
|
|
|
|
winProcesses.Add(winProcess);
|
|
}
|
|
|
|
Log.WriteEnd("GetWindowsProcesses");
|
|
return winProcesses.ToArray();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.WriteError("GetWindowsProcesses", ex);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
[WebMethod]
|
|
public void TerminateWindowsProcess(int pid)
|
|
{
|
|
try
|
|
{
|
|
Log.WriteStart("TerminateWindowsProcess");
|
|
|
|
Process[] processes = Process.GetProcesses();
|
|
foreach (Process process in processes)
|
|
{
|
|
if (process.Id == pid)
|
|
process.Kill();
|
|
}
|
|
|
|
Log.WriteEnd("TerminateWindowsProcess");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.WriteError("TerminateWindowsProcess", ex);
|
|
throw;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Windows Services
|
|
[WebMethod]
|
|
public WindowsService[] GetWindowsServices()
|
|
{
|
|
try
|
|
{
|
|
Log.WriteStart("GetWindowsServices");
|
|
List<WindowsService> winServices = new List<WindowsService>();
|
|
|
|
ServiceController[] services = ServiceController.GetServices();
|
|
foreach (ServiceController service in services)
|
|
{
|
|
WindowsService winService = new WindowsService();
|
|
winService.Id = service.ServiceName;
|
|
winService.Name = service.DisplayName;
|
|
winService.CanStop = service.CanStop;
|
|
winService.CanPauseAndContinue = service.CanPauseAndContinue;
|
|
|
|
WindowsServiceStatus status = WindowsServiceStatus.ContinuePending;
|
|
switch (service.Status)
|
|
{
|
|
case ServiceControllerStatus.ContinuePending: status = WindowsServiceStatus.ContinuePending; break;
|
|
case ServiceControllerStatus.Paused: status = WindowsServiceStatus.Paused; break;
|
|
case ServiceControllerStatus.PausePending: status = WindowsServiceStatus.PausePending; break;
|
|
case ServiceControllerStatus.Running: status = WindowsServiceStatus.Running; break;
|
|
case ServiceControllerStatus.StartPending: status = WindowsServiceStatus.StartPending; break;
|
|
case ServiceControllerStatus.Stopped: status = WindowsServiceStatus.Stopped; break;
|
|
case ServiceControllerStatus.StopPending: status = WindowsServiceStatus.StopPending; break;
|
|
}
|
|
winService.Status = status;
|
|
|
|
winServices.Add(winService);
|
|
}
|
|
|
|
Log.WriteEnd("GetWindowsServices");
|
|
return winServices.ToArray();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.WriteError("GetWindowsServices", ex);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
[WebMethod]
|
|
public void ChangeWindowsServiceStatus(string id, WindowsServiceStatus status)
|
|
{
|
|
try
|
|
{
|
|
Log.WriteStart("ChangeWindowsServiceStatus");
|
|
// get all services
|
|
ServiceController[] services = ServiceController.GetServices();
|
|
|
|
// find required service
|
|
foreach (ServiceController service in services)
|
|
{
|
|
if (String.Compare(service.ServiceName, id, true) == 0)
|
|
{
|
|
if (status == WindowsServiceStatus.Paused
|
|
&& service.Status == ServiceControllerStatus.Running)
|
|
service.Pause();
|
|
else if (status == WindowsServiceStatus.Running
|
|
&& service.Status == ServiceControllerStatus.Stopped)
|
|
service.Start();
|
|
else if (status == WindowsServiceStatus.Stopped
|
|
&& ((service.Status == ServiceControllerStatus.Running) ||
|
|
(service.Status == ServiceControllerStatus.Paused)))
|
|
service.Stop();
|
|
else if (status == WindowsServiceStatus.ContinuePending
|
|
&& service.Status == ServiceControllerStatus.Paused)
|
|
service.Continue();
|
|
}
|
|
}
|
|
Log.WriteEnd("ChangeWindowsServiceStatus");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.WriteError("ChangeWindowsServiceStatus", ex);
|
|
throw;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Web Platform Installer
|
|
|
|
|
|
|
|
private string Linkify(string value)
|
|
{
|
|
if (string.IsNullOrEmpty(value))
|
|
return value;
|
|
|
|
//" qweqwe http://www.helicontech.com/zoo/feed/ asdasdasd"
|
|
Regex link =new Regex("(http[^\\s,]+)(?<![.,])");
|
|
|
|
return link.Replace(value,"<a href=\"$1\" target=\"_blank\">$1</a>");
|
|
}
|
|
|
|
|
|
private WPIProduct ProductToWPIProduct(Product product)
|
|
{
|
|
WPIProduct p = new WPIProduct();
|
|
p.ProductId = product.ProductId;
|
|
p.Summary = product.Summary;
|
|
p.LongDescription = Linkify(product.LongDescription);
|
|
p.Published = product.Published;
|
|
p.Author = product.Author;
|
|
p.AuthorUri = (product.AuthorUri != null) ? product.AuthorUri.ToString() : "";
|
|
p.Title = product.Title;
|
|
p.Link = (product.Link != null) ? product.Link.ToString() : "";
|
|
p.Version = product.Version;
|
|
|
|
if (product.Installers.Count > 0)
|
|
{
|
|
if (product.Installers[0].EulaUrl != null)
|
|
{
|
|
p.EulaUrl = product.Installers[0].EulaUrl.ToString();
|
|
|
|
}
|
|
|
|
if (product.Installers[0].InstallerFile != null)
|
|
{
|
|
if (product.Installers[0].InstallerFile.InstallerUrl != null)
|
|
{
|
|
p.DownloadedLocation = product.Installers[0].InstallerFile.InstallerUrl.ToString();
|
|
}
|
|
p.FileSize = product.Installers[0].InstallerFile.FileSize;
|
|
}
|
|
|
|
}
|
|
|
|
if (product.IconUrl != null)
|
|
{
|
|
p.Logo = product.IconUrl.ToString();
|
|
}
|
|
|
|
p.IsInstalled = product.IsInstalled(true);
|
|
|
|
return p;
|
|
}
|
|
|
|
private void CheckHostingPackagesUpgrades(IList<WPIProduct> products)
|
|
{
|
|
foreach (WPIProduct product in products)
|
|
{
|
|
string installedHostingPackageVersion = GetInstalledHostingPackageVersion(product.ProductId);
|
|
if (!string.IsNullOrEmpty(installedHostingPackageVersion) && string.Compare(product.Version, installedHostingPackageVersion, StringComparison.OrdinalIgnoreCase) > 0)
|
|
{
|
|
product.IsUpgrade = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
private string GetInstalledHostingPackageVersion(string productId)
|
|
{
|
|
string installedVersion = Registry.GetValue("HKEY_LOCAL_MACHINE\\SOFTWARE\\Helicon\\Zoo", productId+"Version", string.Empty) as string;
|
|
if (string.IsNullOrEmpty(installedVersion))
|
|
{
|
|
installedVersion = Registry.GetValue("HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Helicon\\Zoo", productId + "Version", string.Empty) as string;
|
|
}
|
|
|
|
return installedVersion;
|
|
}
|
|
|
|
|
|
[WebMethod]
|
|
public WPIProduct[] GetWPIProducts(string tabId, string keywordId)
|
|
{
|
|
|
|
|
|
try
|
|
{
|
|
Log.WriteStart("GetWPIProducts");
|
|
List<WPIProduct> wpiProducts = new List<WPIProduct>();
|
|
|
|
|
|
WpiHelper wpi = GetWpiFeed();
|
|
|
|
string feedLocation = null;
|
|
if (tabId != null)
|
|
{
|
|
Tab tab = wpi.GetTab(tabId);
|
|
ICollection<string> feeds = tab.FeedList;
|
|
feedLocation = feeds.GetEnumerator().Current;
|
|
}
|
|
|
|
List<Product> products = wpi.GetProductsToInstall(feedLocation, keywordId);
|
|
|
|
if (products != null)
|
|
{
|
|
|
|
|
|
foreach (Product product in products)
|
|
{
|
|
if (null != product && !product.IsApplication)
|
|
{
|
|
wpiProducts.Add(ProductToWPIProduct(product));
|
|
|
|
}
|
|
}
|
|
|
|
// check upgrades for Hosting Packages (ZooPackage keyword)
|
|
if (WPIKeyword.HOSTING_PACKAGE_KEYWORD == keywordId)
|
|
{
|
|
CheckHostingPackagesUpgrades(wpiProducts);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
Log.WriteEnd("GetWPIProducts");
|
|
return wpiProducts.ToArray();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.WriteError("GetWPIProducts", ex);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
|
|
[WebMethod]
|
|
public WPIProduct[] GetWPIProductsFiltered(string filter)
|
|
{
|
|
|
|
|
|
try
|
|
{
|
|
Log.WriteStart("GetWPIProductsFiltered");
|
|
List<WPIProduct> wpiProducts = new List<WPIProduct>();
|
|
|
|
|
|
WpiHelper wpi = GetWpiFeed();
|
|
|
|
List<Product> products = wpi.GetProductsFiltered( filter);
|
|
|
|
if (products != null)
|
|
{
|
|
|
|
|
|
foreach (Product product in products)
|
|
{
|
|
if (null != product && !product.IsApplication)
|
|
{
|
|
wpiProducts.Add(ProductToWPIProduct(product));
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Log.WriteEnd("GetWPIProductsFiltered");
|
|
return wpiProducts.ToArray();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.WriteError("GetWPIProductsFiltered", ex);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
[WebMethod]
|
|
public WPITab[] GetWPITabs()
|
|
{
|
|
try
|
|
{
|
|
Log.WriteStart("GetWPITabs");
|
|
|
|
WpiHelper wpi = GetWpiFeed();
|
|
|
|
List<WPITab> result = new List<WPITab>();
|
|
|
|
foreach (Tab tab in wpi.GetTabs())
|
|
{
|
|
result.Add(new WPITab(tab.Id, tab.Name));
|
|
}
|
|
|
|
|
|
Log.WriteEnd("GetWPITabs");
|
|
|
|
return result.ToArray();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.WriteError("GetWPITabs", ex);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
|
|
static private string[] _feeds = new string[]{};
|
|
|
|
[WebMethod]
|
|
public void InitWPIFeeds(string feedUrls)
|
|
{
|
|
if (string.IsNullOrEmpty(feedUrls))
|
|
{
|
|
throw new Exception("Empty feed list");
|
|
}
|
|
|
|
string[] newFeeds = feedUrls.Split(';');
|
|
|
|
if (newFeeds.Length == 0)
|
|
{
|
|
throw new Exception("Empty feed list");
|
|
}
|
|
if (!ArraysEqual<string>(newFeeds, _feeds))
|
|
{
|
|
Log.WriteInfo("InitWPIFeeds - new value: " + feedUrls);
|
|
|
|
//Feeds settings have been channged
|
|
_feeds = newFeeds;
|
|
wpi = null;
|
|
|
|
}
|
|
}
|
|
|
|
|
|
public static bool ArraysEqual<T>(T[] a1, T[] a2)
|
|
{
|
|
if (ReferenceEquals(a1, a2))
|
|
return true;
|
|
|
|
if (a1 == null || a2 == null)
|
|
return false;
|
|
|
|
if (a1.Length != a2.Length)
|
|
return false;
|
|
|
|
EqualityComparer<T> comparer = EqualityComparer<T>.Default;
|
|
for (int i = 0; i < a1.Length; i++)
|
|
{
|
|
if (!comparer.Equals(a1[i], a2[i])) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
[WebMethod]
|
|
public WPIKeyword[] GetWPIKeywords()
|
|
{
|
|
try
|
|
{
|
|
Log.WriteStart("GetWPIKeywords");
|
|
|
|
WpiHelper wpi = GetWpiFeed();
|
|
|
|
List<WPIKeyword> result = new List<WPIKeyword>();
|
|
|
|
result.Add(new WPIKeyword("", "All"));
|
|
|
|
foreach (Keyword keyword in wpi.GetKeywords())
|
|
{
|
|
if (!wpi.IsKeywordApplication(keyword))
|
|
{
|
|
result.Add(new WPIKeyword(keyword.Id, keyword.Text));
|
|
}
|
|
|
|
}
|
|
|
|
|
|
Log.WriteEnd("GetWPIKeywords");
|
|
|
|
return result.ToArray();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.WriteError("GetWPIKeywords", ex);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
|
|
[WebMethod]
|
|
public WPIProduct[] GetWPIProductsWithDependencies(string[] products)
|
|
{
|
|
try
|
|
{
|
|
Log.WriteStart("GetWPIProductsWithDependencies");
|
|
|
|
WpiHelper wpi = GetWpiFeed();
|
|
|
|
List<WPIProduct> result = new List<WPIProduct>();
|
|
foreach (Product product in wpi.GetProductsToInstallWithDependencies(products))
|
|
{
|
|
result.Add(ProductToWPIProduct(product));
|
|
}
|
|
|
|
Log.WriteEnd("GetWPIProductsWithDependencies");
|
|
|
|
return result.ToArray();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.WriteError("GetWPIProductsWithDependencies", ex);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
static Process _WpiServiceExe = null;
|
|
|
|
[WebMethod]
|
|
public void InstallWPIProducts(string[] products)
|
|
{
|
|
try
|
|
{
|
|
Log.WriteStart("InstallWPIProducts");
|
|
|
|
StartWpiService();
|
|
|
|
RegisterWpiService();
|
|
|
|
WPIServiceContract client = new WPIServiceContract();
|
|
|
|
client.Initialize(_feeds);
|
|
client.BeginInstallation(products);
|
|
|
|
|
|
|
|
|
|
|
|
Log.WriteEnd("InstallWPIProducts");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.WriteError("InstallWPIProducts", ex);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
|
|
private void StartWpiService()
|
|
{
|
|
string binFolder = HttpContext.Current.Server.MapPath("/bin/");
|
|
string workingDirectory = Path.Combine(Environment.ExpandEnvironmentVariables("%SystemRoot%"), "Temp\\zoo.wpi");
|
|
|
|
//string newUserProfile = Path.Combine(Environment.ExpandEnvironmentVariables("%SystemRoot%"), "Temp\\zoo.wpi");
|
|
//string newAppData = Path.Combine(newUserProfile, "Roaming");
|
|
//string newLocalAppData = Path.Combine(newUserProfile, "Local");
|
|
//try
|
|
//{
|
|
// Directory.CreateDirectory(newUserProfile);
|
|
// Directory.CreateDirectory(newAppData);
|
|
// Directory.CreateDirectory(newLocalAppData);
|
|
//}
|
|
//catch (Exception)
|
|
//{
|
|
// //throw;
|
|
//}
|
|
|
|
|
|
Process wpiServiceExe = new Process();
|
|
wpiServiceExe.StartInfo = new ProcessStartInfo(Path.Combine(binFolder, "WebsitePanel.Server.WPIService.exe"));
|
|
wpiServiceExe.StartInfo.WorkingDirectory = workingDirectory;
|
|
wpiServiceExe.StartInfo.UseShellExecute = false;
|
|
wpiServiceExe.StartInfo.LoadUserProfile = true;
|
|
wpiServiceExe.StartInfo.EnvironmentVariables["MySqlPassword"] = "";
|
|
//wpiServiceExe.StartInfo.EnvironmentVariables["UserProfile"] = newUserProfile;
|
|
//wpiServiceExe.StartInfo.EnvironmentVariables["LocalAppData"] = newLocalAppData;
|
|
//wpiServiceExe.StartInfo.EnvironmentVariables["AppData"] = newAppData;
|
|
if (wpiServiceExe.Start())
|
|
{
|
|
_WpiServiceExe = wpiServiceExe;
|
|
}
|
|
}
|
|
|
|
[WebMethod]
|
|
public void CancelInstallWPIProducts()
|
|
{
|
|
try
|
|
{
|
|
Log.WriteStart("CancelInstallWPIProducts");
|
|
|
|
KillWpiService();
|
|
|
|
|
|
Log.WriteEnd("CancelInstallWPIProducts");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.WriteError("CancelInstallWPIProducts", ex);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
private void KillWpiService()
|
|
{
|
|
//kill own service
|
|
if (_WpiServiceExe != null && !_WpiServiceExe.HasExited)
|
|
{
|
|
_WpiServiceExe.Kill();
|
|
_WpiServiceExe = null;
|
|
}
|
|
else
|
|
{
|
|
//find WebsitePanel.Server.WPIService.exe
|
|
Process[] wpiservices = Process.GetProcessesByName("WebsitePanel.Server.WPIService");
|
|
foreach (Process p in wpiservices)
|
|
{
|
|
p.Kill();
|
|
}
|
|
}
|
|
}
|
|
|
|
[WebMethod]
|
|
public string GetWPIStatus()
|
|
{
|
|
try
|
|
{
|
|
Log.WriteStart("GetWPIStatus");
|
|
|
|
RegisterWpiService();
|
|
|
|
WPIServiceContract client = new WPIServiceContract();
|
|
|
|
string status = client.GetStatus();
|
|
|
|
Log.WriteEnd("GetWPIStatus");
|
|
|
|
return status; //OK
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// done or error
|
|
|
|
if (_WpiServiceExe == null || _WpiServiceExe.HasExited)
|
|
{
|
|
// reset WpiHelper for refresh status
|
|
wpi = null;
|
|
return ""; //OK
|
|
}
|
|
|
|
Log.WriteError("GetWPIStatus", ex);
|
|
|
|
return ex.ToString();
|
|
}
|
|
}
|
|
|
|
[WebMethod]
|
|
public string WpiGetLogFileDirectory()
|
|
{
|
|
try
|
|
{
|
|
Log.WriteStart("WpiGetLogFileDirectory");
|
|
|
|
RegisterWpiService();
|
|
|
|
WPIServiceContract client = new WPIServiceContract();
|
|
|
|
string result = client.GetLogFileDirectory();
|
|
|
|
Log.WriteEnd("WpiGetLogFileDirectory");
|
|
|
|
return result; //OK
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
Log.WriteError("WpiGetLogFileDirectory", ex);
|
|
|
|
//throw;
|
|
return string.Empty;
|
|
}
|
|
}
|
|
|
|
[WebMethod]
|
|
public SettingPair[] WpiGetLogsInDirectory(string Path)
|
|
{
|
|
try
|
|
{
|
|
Log.WriteStart("WpiGetLogsInDirectory");
|
|
|
|
ArrayList result = new ArrayList();
|
|
|
|
string[] filePaths = Directory.GetFiles(Path);
|
|
foreach (string filePath in filePaths)
|
|
{
|
|
using (StreamReader streamReader = new StreamReader(filePath))
|
|
{
|
|
string fileContent = SecurityElement.Escape(StringUtils.CleanupASCIIControlCharacters(streamReader.ReadToEnd()));
|
|
result.Add(new SettingPair(filePath, fileContent));
|
|
}
|
|
|
|
}
|
|
|
|
Log.WriteEnd("WpiGetLogFileDirectory");
|
|
|
|
return (SettingPair[])result.ToArray(typeof(SettingPair)); //OK
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
Log.WriteError("WpiGetLogFileDirectory", ex);
|
|
|
|
//throw;
|
|
return null;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static WpiHelper wpi = null;
|
|
WpiHelper GetWpiFeed()
|
|
{
|
|
if (_feeds.Length == 0)
|
|
{
|
|
throw new Exception("Empty feed list");
|
|
}
|
|
|
|
if (null == wpi)
|
|
{
|
|
wpi = new WpiHelper(_feeds);
|
|
}
|
|
return wpi;
|
|
}
|
|
|
|
private static object _lockRegisterWpiService = new object();
|
|
private void RegisterWpiService()
|
|
{
|
|
lock (_lockRegisterWpiService)
|
|
{
|
|
|
|
|
|
try
|
|
{
|
|
ChannelServices.RegisterChannel(new TcpChannel(), true);
|
|
}
|
|
catch (System.Exception)
|
|
{
|
|
//ignor
|
|
}
|
|
|
|
if (null == RemotingConfiguration.IsWellKnownClientType(typeof(WPIServiceContract)))
|
|
{
|
|
RemotingConfiguration.RegisterWellKnownClientType(typeof(WPIServiceContract), string.Format("tcp://localhost:{0}/WPIServiceContract", WPIServiceContract.PORT));
|
|
}
|
|
|
|
try
|
|
{
|
|
WPIServiceContract client = new WPIServiceContract();
|
|
client.Ping();
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//unable to connect
|
|
//try to restart service
|
|
KillWpiService();
|
|
//StartWpiService();
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
#endregion GetWPIProducts
|
|
|
|
|
|
#region Event Viewer
|
|
[WebMethod]
|
|
public List<string> GetLogNames()
|
|
{
|
|
List<string> logs = new List<string>();
|
|
EventLog[] eventLogs = EventLog.GetEventLogs();
|
|
foreach (EventLog eventLog in eventLogs)
|
|
{
|
|
logs.Add(eventLog.LogDisplayName);
|
|
}
|
|
return logs;
|
|
}
|
|
|
|
[WebMethod]
|
|
public List<SystemLogEntry> GetLogEntries(string logName)
|
|
{
|
|
SystemLogEntriesPaged result = new SystemLogEntriesPaged();
|
|
List<SystemLogEntry> entries = new List<SystemLogEntry>();
|
|
|
|
if (String.IsNullOrEmpty(logName))
|
|
return entries;
|
|
|
|
EventLog log = new EventLog(logName);
|
|
EventLogEntryCollection logEntries = log.Entries;
|
|
int count = logEntries.Count;
|
|
|
|
// iterate in reverse order
|
|
for (int i = count - 1; i >= 0; i--)
|
|
entries.Add(CreateLogEntry(logEntries[i], false));
|
|
|
|
return entries;
|
|
}
|
|
|
|
[WebMethod]
|
|
public SystemLogEntriesPaged GetLogEntriesPaged(string logName, int startRow, int maximumRows)
|
|
{
|
|
SystemLogEntriesPaged result = new SystemLogEntriesPaged();
|
|
List<SystemLogEntry> entries = new List<SystemLogEntry>();
|
|
|
|
if (String.IsNullOrEmpty(logName))
|
|
{
|
|
result.Count = 0;
|
|
result.Entries = new SystemLogEntry[] { };
|
|
return result;
|
|
}
|
|
|
|
EventLog log = new EventLog(logName);
|
|
EventLogEntryCollection logEntries = log.Entries;
|
|
int count = logEntries.Count;
|
|
result.Count = count;
|
|
|
|
// iterate in reverse order
|
|
startRow = count - 1 - startRow;
|
|
int endRow = startRow - maximumRows + 1;
|
|
if (endRow < 0)
|
|
endRow = 0;
|
|
|
|
for (int i = startRow; i >= endRow; i--)
|
|
entries.Add(CreateLogEntry(logEntries[i], true));
|
|
|
|
result.Entries = entries.ToArray();
|
|
|
|
return result;
|
|
}
|
|
|
|
[WebMethod]
|
|
public void ClearLog(string logName)
|
|
{
|
|
EventLog log = new EventLog(logName);
|
|
log.Clear();
|
|
}
|
|
|
|
private SystemLogEntry CreateLogEntry(EventLogEntry logEntry, bool includeMessage)
|
|
{
|
|
SystemLogEntry entry = new SystemLogEntry();
|
|
switch (logEntry.EntryType)
|
|
{
|
|
case EventLogEntryType.Error: entry.EntryType = SystemLogEntryType.Error; break;
|
|
case EventLogEntryType.Warning: entry.EntryType = SystemLogEntryType.Warning; break;
|
|
case EventLogEntryType.Information: entry.EntryType = SystemLogEntryType.Information; break;
|
|
case EventLogEntryType.SuccessAudit: entry.EntryType = SystemLogEntryType.SuccessAudit; break;
|
|
case EventLogEntryType.FailureAudit: entry.EntryType = SystemLogEntryType.FailureAudit; break;
|
|
}
|
|
|
|
entry.Created = logEntry.TimeGenerated;
|
|
entry.Source = logEntry.Source;
|
|
entry.Category = logEntry.Category;
|
|
entry.EventID = logEntry.InstanceId;
|
|
entry.UserName = logEntry.UserName;
|
|
entry.MachineName = logEntry.MachineName;
|
|
|
|
if (includeMessage)
|
|
entry.Message = logEntry.Message;
|
|
|
|
return entry;
|
|
}
|
|
#endregion
|
|
|
|
#region Reboot
|
|
[WebMethod]
|
|
public void RebootSystem()
|
|
{
|
|
try
|
|
{
|
|
Log.WriteStart("RebootSystem");
|
|
WmiHelper wmi = new WmiHelper("root\\cimv2");
|
|
ManagementObjectCollection objOses = wmi.ExecuteQuery("SELECT * FROM Win32_OperatingSystem");
|
|
foreach (ManagementObject objOs in objOses)
|
|
{
|
|
objOs.Scope.Options.EnablePrivileges = true;
|
|
objOs.InvokeMethod("Reboot", null);
|
|
}
|
|
Log.WriteEnd("RebootSystem");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.WriteError("RebootSystem", ex);
|
|
throw;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region System Commands
|
|
[WebMethod]
|
|
public string ExecuteSystemCommand(string path, string args)
|
|
{
|
|
try
|
|
{
|
|
Log.WriteStart("ExecuteSystemCommand");
|
|
string result = FileUtils.ExecuteSystemCommand(path, args);
|
|
Log.WriteEnd("ExecuteSystemCommand");
|
|
return result;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.WriteError("ExecuteSystemCommand", ex);
|
|
throw;
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
|
|
}
|