/// <summary>
/// Install an executable as a service.
/// </summary>
/// <param name="assemblyPath">The path to the executable.</param>
/// <param name="serviceName">The name of the service.</param>
/// <param name="displayName">THe display name of the service.</param>
/// <param name="description">The description of the service.</param>
/// <param name="startType">The startup type.</param>
/// <param name="userName">The username to run as.</param>
/// <param name="password">The password of the user.</param>
/// <param name="dependancies"></param>
public static void InstallService(string assemblyPath, string serviceName, string displayName, string description,
ServiceStartMode startType, string userName = "", string password = "", IEnumerable<string> dependancies = null)
{
using (var procesServiceInstaller = new ServiceProcessInstaller())
{
if (string.IsNullOrEmpty(userName))
{
procesServiceInstaller.Account = ServiceAccount.LocalSystem;
}
else
{
procesServiceInstaller.Account = ServiceAccount.User;
procesServiceInstaller.Username = userName;
procesServiceInstaller.Password = password;
}
using (var installer = new ServiceInstaller())
{
var cmdline = new[] { string.Format("/assemblypath={0}", assemblyPath) };
var context = new InstallContext(string.Empty, cmdline);
installer.Context = context;
installer.DisplayName = displayName;
installer.Description = description;
installer.ServiceName = serviceName;
installer.StartType = startType;
installer.Parent = procesServiceInstaller;
if (dependancies != null)
{
installer.ServicesDependedOn = dependancies.ToArray();
}
IDictionary state = new Hashtable();
try
{
installer.Install(state);
installer.Commit(state);
}
catch (Exception ex)
{
installer.Rollback(state);
throw new Exception("Failed to install the service.", ex);
}
}
}
}
//Cria um serviço novo e registra o mesmo no caminho System\Current\Services
public static void CreateService(string executablePath, string serviceName, string serviceDescription, string DisplayServiceName)
{
string retorno = VerifyInstanceTotal(@"SYSTEM\CurrentControlSet\services\" + serviceName, "DisplayName");
if (retorno == "")
{
ServiceProcessInstaller ProcesServiceInstaller = new ServiceProcessInstaller();
ProcesServiceInstaller.Account = ServiceAccount.User;
ServiceInstaller servico = new ServiceInstaller();
InstallContext Context = new System.Configuration.Install.InstallContext();
String path = String.Format("/assemblypath={0}", executablePath);
String[] cmdline = { path };
Context = new System.Configuration.Install.InstallContext("", cmdline);
servico.Context = Context;
servico.DisplayName = DisplayServiceName;
servico.Description = serviceDescription;
servico.ServiceName = serviceName;
servico.StartType = ServiceStartMode.Automatic;
servico.Parent = ProcesServiceInstaller;
System.Collections.Specialized.ListDictionary state = new System.Collections.Specialized.ListDictionary();
ServiceController serviceExists = new ServiceController(serviceName);
servico.Install(state);
}
}
public void ItPersistsArgumentsInFile(
string containerDirectory, string machineIp, string syslogHostIp, string syslogPort, string machineName)
{
var context = new InstallContext();
context.Parameters.Add("CONTAINER_DIRECTORY", containerDirectory);
context.Parameters.Add("MACHINE_IP", machineIp);
context.Parameters.Add("SYSLOG_HOST_IP", syslogHostIp);
context.Parameters.Add("SYSLOG_PORT", syslogPort);
context.Parameters.Add("MACHINE_NAME", machineName);
configurationManager.Context = context;
configurationManager.OnBeforeInstall(null);
var acl = Directory.GetAccessControl(tempDirectory.ToString());
var accessRules = acl.GetAccessRules(true, true, typeof(SecurityIdentifier));
Assert.Equal(accessRules.Count, 1);
var rule = (FileSystemAccessRule)accessRules[0];
Assert.Equal(rule.AccessControlType, AccessControlType.Allow);
Assert.Equal(new SecurityIdentifier(WellKnownSidType.BuiltinAdministratorsSid, null), rule.IdentityReference);
Assert.Equal(rule.FileSystemRights, FileSystemRights.FullControl);
var javaScriptSerializer = new System.Web.Script.Serialization.JavaScriptSerializer();
var parametersPath = Path.Combine(tempDirectory.ToString(), "parameters.json");
var jsonString = File.ReadAllText(parametersPath);
var hash = javaScriptSerializer.Deserialize<Dictionary<string, string>>(jsonString);
Assert.Equal(hash["CONTAINER_DIRECTORY"], containerDirectory);
Assert.Equal(hash["MACHINE_IP"], machineIp);
Assert.Equal(hash["SYSLOG_HOST_IP"], syslogHostIp);
Assert.Equal(hash["SYSLOG_PORT"], syslogPort);
Assert.Equal(hash["MACHINE_NAME"], machineName);
}
public virtual void Install(string serviceName)
{
Logger.Info("Installing service '{0}'", serviceName);
var installer = new ServiceProcessInstaller
{
Account = ServiceAccount.LocalSystem
};
var serviceInstaller = new ServiceInstaller();
String[] cmdline = { @"/assemblypath=" + Process.GetCurrentProcess().MainModule.FileName };
var context = new InstallContext("service_install.log", cmdline);
serviceInstaller.Context = context;
serviceInstaller.DisplayName = serviceName;
serviceInstaller.ServiceName = serviceName;
serviceInstaller.Description = "NzbDrone Application Server";
serviceInstaller.StartType = ServiceStartMode.Automatic;
serviceInstaller.ServicesDependedOn = new[] { "EventLog", "Tcpip" };
serviceInstaller.Parent = installer;
serviceInstaller.Install(new ListDictionary());
Logger.Info("Service Has installed successfully.");
}
static void Main(string[] args)
{
string opt = null;
if (args.Length >= 1)
{
opt = args[0].ToLower();
}
if (opt == "/install" || opt == "/uninstall")
{
TransactedInstaller ti = new TransactedInstaller();
MonitorInstaller mi = new MonitorInstaller("OPC_FILE_WATCHER");
ti.Installers.Add(mi);
string path = String.Format("/assemblypath={0}", Assembly.GetExecutingAssembly().Location);
string[] cmdline = { path };
InstallContext ctx = new InstallContext("", cmdline);
ti.Context = ctx;
if (opt == "/install")
{
Console.WriteLine("Installing");
ti.Install(new Hashtable());
}
else if (opt == "/uninstall")
{
Console.WriteLine("Uninstalling");
try { ti.Uninstall(null); } catch (InstallException ie) { Console.WriteLine(ie.ToString()); }
}
}
else
{
ServiceBase[] services;
services = new ServiceBase[] { new OPCDataParser() }; ServiceBase.Run(services);
}
}
public FrmConfig(System.Configuration.Install.InstallContext context, InstallController ctrl)
{
formContext = context;
this.ctrl = ctrl;
InitializeComponent();
this.CenterToScreen();
}
private void PrintStartText(string activity)
{
if (this.UseNewContext)
{
InstallContext context = this.CreateAssemblyContext();
if (base.Context != null)
{
base.Context.LogMessage(System.Configuration.Install.Res.GetString("InstallLogContent", new object[] { this.Path }));
base.Context.LogMessage(System.Configuration.Install.Res.GetString("InstallFileLocation", new object[] { context.Parameters["logfile"] }));
}
base.Context = context;
}
base.Context.LogMessage(string.Format(CultureInfo.InvariantCulture, activity, new object[] { this.Path }));
base.Context.LogMessage(System.Configuration.Install.Res.GetString("InstallLogParameters"));
if (base.Context.Parameters.Count == 0)
{
base.Context.LogMessage(" " + System.Configuration.Install.Res.GetString("InstallLogNone"));
}
IDictionaryEnumerator enumerator = (IDictionaryEnumerator)base.Context.Parameters.GetEnumerator();
while (enumerator.MoveNext())
{
string key = (string)enumerator.Key;
string str2 = (string)enumerator.Value;
if (key.Equals("password", StringComparison.InvariantCultureIgnoreCase))
{
str2 = "********";
}
base.Context.LogMessage(" " + key + " = " + str2);
}
}
private void PrintStartText(string activity)
{
if (UseNewContext)
{
InstallContext newContext = CreateAssemblyContext();
// give a warning in the main log file that we're switching over to the assembly-specific file
if (Context != null)
{
Context.LogMessage(Res.GetString(Res.InstallLogContent, Path));
Context.LogMessage(Res.GetString(Res.InstallFileLocation, newContext.Parameters["logfile"]));
}
Context = newContext;
}
// print out some info on the install
Context.LogMessage(string.Format(activity, Path));
Context.LogMessage(Res.GetString(Res.InstallLogParameters));
if (Context.Parameters.Count == 0)
{
Context.LogMessage(" " + Res.GetString(Res.InstallLogNone));
}
IDictionaryEnumerator en = (IDictionaryEnumerator)Context.Parameters.GetEnumerator();
while (en.MoveNext())
{
Context.LogMessage(" " + (string)en.Key + " = " + (string)en.Value);
}
}
private InstallContext CreateAssemblyContext()
{
InstallContext context = new InstallContext(System.IO.Path.ChangeExtension(Path, ".InstallLog"), CommandLine);
context.Parameters["assemblypath"] = Path;
return(context);
}
//Cria um serviço novo e registra o mesmo no caminho System\Current\Services
public static void CreateService(string executablePath, string serviceName, string serviceDescription, string displayServiceName)
{
ServiceProcessInstaller ProcesServiceInstaller = new ServiceProcessInstaller();
ProcesServiceInstaller.Account = ServiceAccount.User;
ServiceInstaller service = new ServiceInstaller();
InstallContext Context = new System.Configuration.Install.InstallContext();
String path = String.Format("/assemblypath={0}", executablePath);
String[] cmdline = { path };
Context = new System.Configuration.Install.InstallContext("", cmdline);
service.Context = Context;
service.DisplayName = displayServiceName;
service.Description = serviceDescription;
service.ServiceName = serviceName;
service.StartType = ServiceStartMode.Automatic;
service.Parent = ProcesServiceInstaller;
System.Collections.Specialized.ListDictionary state = new System.Collections.Specialized.ListDictionary();
ServiceController serviceExists = new ServiceController(serviceName);
service.Install(state);
}
public CustomInstaller(Service service)
{
_service = service;
Installers.Add(GetServiceInstaller());
Installers.Add(GetServiceProcessInstaller());
var baseDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "logs");
Context = new InstallContext(
null,
new[]
{
"/LogToConsole=true",
"/InstallStateDir=" + Path.Combine(baseDir, "service-install.state"),
"/LogFile=" + Path.Combine(baseDir, "service-install.log")
});
foreach (string key in Context.Parameters.Keys)
{
Writer.WriteLine("{0}={1}", key, Context.Parameters[key]);
}
if (_service.StartMode == ServiceStartMode.Automatic)
{
Committed += (sender, args) => new ServiceController(service.ServiceName).Start();
}
}
public void RunPrecompiler()
{
var appBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase;
var targetFile = Path.Combine(appBase, "RunPrecompiler.dll");
File.Delete(targetFile);
var parent = new ParentInstaller();
var precompile = new PrecompileInstaller();
precompile.TargetAssemblyFile = targetFile;
precompile.ViewPath = "MonoRail.Tests.Views";
precompile.DescribeBatch += ((sender, e) => e.Batch.For<StubController>().Include("*").Include("_*"));
var context = new InstallContext();
var state = new Hashtable();
parent.Installers.Add(precompile);
parent.Install(state);
parent.Commit(state);
Assert.That(File.Exists(targetFile), "File exists");
var result = Assembly.LoadFrom(targetFile);
Assert.AreEqual(3, result.GetTypes().Count());
}
public void ItPersistsArgumentsInFile(
string containerDirectory, string machineIp, string syslogHostIp, string syslogPort, string machineName)
{
using(var tempDirectory = new TempDirectory())
{
var configurationManager = new ConfigurationManagerTest();
var context = new InstallContext();
context.Parameters.Add("CONTAINER_DIRECTORY", containerDirectory);
context.Parameters.Add("MACHINE_IP", machineIp);
context.Parameters.Add("SYSLOG_HOST_IP", syslogHostIp);
context.Parameters.Add("SYSLOG_PORT", syslogPort);
context.Parameters.Add("assemblypath", tempDirectory.ToString());
context.Parameters.Add("MACHINE_NAME", machineName);
configurationManager.Context = context;
configurationManager.OnBeforeInstall(null);
var javaScriptSerializer = new System.Web.Script.Serialization.JavaScriptSerializer();
var jsonString = File.ReadAllText(Path.Combine(tempDirectory.ToString(), @"..\parameters.json"));
var hash = javaScriptSerializer.Deserialize<Dictionary<string, string>>(jsonString);
Assert.Equal(hash["CONTAINER_DIRECTORY"], containerDirectory);
Assert.Equal(hash["MACHINE_IP"], machineIp);
Assert.Equal(hash["SYSLOG_HOST_IP"], syslogHostIp);
Assert.Equal(hash["SYSLOG_PORT"], syslogPort);
Assert.Equal(hash["MACHINE_NAME"], machineName);
}
}
public FrmConfig(System.Configuration.Install.InstallContext context, InstallController ctrl)
{
formContext = context;
this.ctrl = ctrl;
InitializeComponent();
this.CenterToScreen();
}
public InstallContext(string logFilePath, string[] commandLine)
{
this.parameters = InstallContext.ParseCommandLine(commandLine);
if (this.Parameters["logfile"] == null && logFilePath != null)
{
this.Parameters["logfile"] = logFilePath;
}
}
public override void Install(IDictionary stateSaver)
{
string strAssPath = "/assemblypath=\"{0}\" \"" + this.Context.Parameters["path"]+"\"";
Context = new InstallContext("", new string[] { String.Format(strAssPath, System.Reflection.Assembly.GetExecutingAssembly().Location) });
base.Install(stateSaver);
}
public void DeleteService(string i_ServiceName)
{
ServiceInstaller ServiceInstallerObj = new ServiceInstaller();
InstallContext Context = new InstallContext(AppDomain.CurrentDomain.BaseDirectory + "\\uninstalllog.log", null);
ServiceInstallerObj.Context = Context;
ServiceInstallerObj.ServiceName = i_ServiceName;
ServiceInstallerObj.Uninstall(null);
}
/// <summary>
/// UnInstalls the Windows service with the given "installer" object.
/// </summary>
/// <param name="pi"></param>
/// <param name="pathToService"></param>
public static void uninstallService(Installer pi, string pathToService)
{
TransactedInstaller ti = new TransactedInstaller ();
ti.Installers.Add (pi);
string[] cmdline = {pathToService};
InstallContext ctx = new InstallContext ("Uninstall.log", cmdline );
ti.Context = ctx;
ti.Uninstall ( null );
}
public InstallContext(string logFilePath, string[] commandLine)
{
Parameters = InstallContext.ParseCommandLine(commandLine);
if (Parameters["logfile"] != null || logFilePath == null)
{
return;
}
Parameters["logfile"] = logFilePath;
}
public FrmDbInstall(System.Configuration.Install.InstallContext context, InstallController ctrl)
{
Logger.info("FrmDbInstall");
formContext = context;
this.ctrl = ctrl;
InitializeComponent();
this.CenterToScreen();
}
/// <summary>
/// Installs the Windows service with the given "installer" object.
/// </summary>
/// <param name="installer">The installer.</param>
/// <param name="pathToService">The path to service.</param>
public static void InstallService(Installer installer, string pathToService)
{
TransactedInstaller ti = new TransactedInstaller();
ti.Installers.Add(installer);
string[] cmdline = { pathToService };
InstallContext ctx = new InstallContext("Install.log", cmdline);
ti.Context = ctx;
ti.Install(new Hashtable());
}
public FrmDbInstall(System.Configuration.Install.InstallContext context, InstallController ctrl)
{
Logger.info("FrmDbInstall");
formContext = context;
this.ctrl = ctrl;
InitializeComponent();
this.CenterToScreen();
}
public void StartForeground(string[] args)
{
if (args.Length > 0)
{
switch (args[0])
{
case "/install":
case "-install":
case "--install":
{
var directory = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Barcodes");
if (args.Length > 1)
{
directory = Path.GetFullPath(args[1]);
}
if (!Directory.Exists(directory))
throw new ArgumentException(String.Format("The barcode directory {0} doesn't exists.", directory));
var transactedInstaller = new TransactedInstaller();
var serviceInstaller = new ServiceInstaller();
transactedInstaller.Installers.Add(serviceInstaller);
var ctx = new InstallContext();
ctx.Parameters["assemblypath"] = String.Format("{0} \"{1}\"", Assembly.GetExecutingAssembly().Location, directory);
transactedInstaller.Context = ctx;
transactedInstaller.Install(new Hashtable());
Console.WriteLine("The service is installed. Barcode images have to be placed into the directory {0}.", directory);
}
return;
case "/uninstall":
case "-uninstall":
case "--uninstall":
{
var transactedInstaller = new TransactedInstaller();
var serviceInstaller = new ServiceInstaller();
transactedInstaller.Installers.Add(serviceInstaller);
var ctx = new InstallContext();
ctx.Parameters["assemblypath"] = String.Format("{0}", Assembly.GetExecutingAssembly().Location);
transactedInstaller.Context = ctx;
transactedInstaller.Uninstall(null);
Console.WriteLine("The service is uninstalled.");
}
return;
default:
if (args[0][0] != '/' &&
args[0][0] != '-')
throw new ArgumentException(String.Format("The argument {0} isn't supported.", args[0]));
break;
}
}
OnStart(args);
Console.ReadLine();
}
private TransactedInstaller InitializeInstaller(Dictionary<string, string> parameters)
{
SetupParameters(parameters);
var ti = new TransactedInstaller();
var ai = new AssemblyInstaller(Path.Combine(_sourcePath, _serviceExecutable), _parameters);
ti.Installers.Add(ai);
var ic = new InstallContext("Install.log", _parameters);
ti.Context = ic;
return ti;
}
/// <summary>
/// setup the Babalu perfmon counters
/// </summary>
/// <param name="context"></param>
public static void SetupPerfmonCounters(InstallContext context)
{
context.LogMessage("Perfmon Babalu counters installer begins");
#if !DEBUG
if (PerformanceCounterCategory.Exists(BabaluCounterDescriptions.CounterCategory))
PerformanceCounterCategory.Delete(BabaluCounterDescriptions.CounterCategory);
#endif
BabaluCounterDescriptions.InstallCounters();
context.LogMessage("Perfmon Babalu counters installer ends");
}
private InstallContext CreateAssemblyContext()
{
InstallContext context = new InstallContext(System.IO.Path.ChangeExtension(this.Path, ".InstallLog"), this.CommandLine);
if (base.Context != null)
{
context.Parameters["logtoconsole"] = base.Context.Parameters["logtoconsole"];
}
context.Parameters["assemblypath"] = this.Path;
return(context);
}
private InstallContext CreateAssemblyContext()
{
var installContext = new InstallContext(System.IO.Path.ChangeExtension(Path, ".InstallLog"), CommandLine);
if (Context != null)
{
installContext.Parameters["logtoconsole"] = Context.Parameters["logtoconsole"];
}
installContext.Parameters["assemblypath"] = Path;
return(installContext);
}
// Perform the installation process, saving the previous
// state in the "stateSaver" object.
public override void Install(IDictionary stateSaver)
{
// Make sure that we have a context.
if (Context == null)
{
Context = new InstallContext("con", new String [0]);
}
// Log the start of the transaction.
Context.LogLine(S._("Installer_BeginInstallTransaction"));
try
{
// Run the installation process.
try
{
Context.LogLine(S._("Installer_BeginInstall"));
base.Install(stateSaver);
}
catch (SystemException)
{
// Roll back the transaction.
Context.LogLine(S._("Installer_BeginRollback"));
try
{
Rollback(stateSaver);
}
catch (SystemException)
{
// Ignore errors during rollback.
}
Context.LogLine(S._("Installer_EndRollback"));
// Notify the caller about the rollback.
throw new InvalidOperationException
(S._("Installer_RollbackPerformed"));
}
// Commit the transaction.
Context.LogLine(S._("Installer_BeginCommit"));
try
{
Commit(stateSaver);
}
finally
{
Context.LogLine(S._("Installer_EndCommit"));
}
}
finally
{
Context.LogLine(S._("Installer_EndInstallTransaction"));
}
}
// Perform the installation process, saving the previous
// state in the "stateSaver" object.
public override void Install(IDictionary stateSaver)
{
// Make sure that we have a context.
if(Context == null)
{
Context = new InstallContext("con", new String [0]);
}
// Log the start of the transaction.
Context.LogLine(S._("Installer_BeginInstallTransaction"));
try
{
// Run the installation process.
try
{
Context.LogLine(S._("Installer_BeginInstall"));
base.Install(stateSaver);
}
catch(SystemException)
{
// Roll back the transaction.
Context.LogLine(S._("Installer_BeginRollback"));
try
{
Rollback(stateSaver);
}
catch(SystemException)
{
// Ignore errors during rollback.
}
Context.LogLine(S._("Installer_EndRollback"));
// Notify the caller about the rollback.
throw new InvalidOperationException
(S._("Installer_RollbackPerformed"));
}
// Commit the transaction.
Context.LogLine(S._("Installer_BeginCommit"));
try
{
Commit(stateSaver);
}
finally
{
Context.LogLine(S._("Installer_EndCommit"));
}
}
finally
{
Context.LogLine(S._("Installer_EndInstallTransaction"));
}
}
public bool DeployService()
{
try
{
Installer installer = new Installer();
ServiceProcessInstaller processInstaller = new ServiceProcessInstaller();
EventLogInstaller customEventLogInstaller;
processInstaller.Account = _settings.ServiceAccount;
if (processInstaller.Account == ServiceAccount.User)
{
processInstaller.Username = _settings.ServiceAccountUserName;
processInstaller.Password = _settings.ServiceAccountPassword;
}
ServiceInstaller serviceInstaller = new ServiceInstaller();
InstallContext Context = new System.Configuration.Install.InstallContext();
String path = String.Format("/assemblypath={0}", _settings.ServiceExecutalePath);//String.Format("/assemblypath={0}", @"<<path of executable of window service>>");
String[] cmdline = { path };
Context = new System.Configuration.Install.InstallContext("", cmdline);
serviceInstaller.Context = Context;
serviceInstaller.DisplayName = _settings.ServiceName;
serviceInstaller.ServiceName = _settings.ServiceName;
serviceInstaller.Description = _settings.ServiceDescription;
serviceInstaller.StartType = _settings.ServiceStartMode;
//usama
serviceInstaller.Parent = processInstaller;
// Create an instance of 'EventLogInstaller'.
customEventLogInstaller = new EventLogInstaller();
// Set the 'Source' of the event log, to be created.
customEventLogInstaller.Source = "customTayaLog";
// Set the 'Event Log' that the source is created in.
customEventLogInstaller.Log = "TayaApplication";
// Add myEventLogInstaller to 'InstallerCollection'.
//serviceInstaller.Installers.Add(customEventLogInstaller);
System.Collections.Specialized.ListDictionary state = new System.Collections.Specialized.ListDictionary();
serviceInstaller.Install(state);
return(true);
}
catch (Exception ex)
{
LogHelper.LogException(ex, "ServiceUtility.DeployService", LogType.Watcher);
return(false);
}
}
public void SetUp ()
{
string logFile = "./InstallContextTestLog.txt";
string[] param = new string[] {
"/Option1=value1",
"-Option2=value2",
"-Option3",
"Option4",
"/Option5=True",
"/Option6=no"
};
ic = new InstallContext (logFile, param);
}
public void ItPersistsArgumentsInFile(
string consulDomain, string consulIps, Uri cfEtcdCluster, string loggregatorSharedSecret,
string redundancyZone, string stack, string machineIp)
{
var context = new InstallContext();
var consulEncryptFile = Path.Combine(sourceDirectory.ToString(), "encrypt_key");
File.WriteAllText(consulEncryptFile, "content");
context.Parameters.Add("CONSUL_DOMAIN", consulDomain);
context.Parameters.Add("CONSUL_IPS", consulIps);
context.Parameters.Add("CF_ETCD_CLUSTER", cfEtcdCluster.ToString());
context.Parameters.Add("LOGGREGATOR_SHARED_SECRET", loggregatorSharedSecret);
context.Parameters.Add("REDUNDANCY_ZONE", redundancyZone);
context.Parameters.Add("STACK", stack);
context.Parameters.Add("MACHINE_IP", machineIp);
context.Parameters.Add("CONSUL_ENCRYPT_FILE", consulEncryptFile);
context.Parameters.Add("REP_REQUIRE_TLS", false.ToString());
configurationManager.Context = context;
configurationManager.OnBeforeInstall(null);
DirectorySecurity directoryAcl = Directory.GetAccessControl(tempDirectory.ToString());
AuthorizationRuleCollection accessRules = directoryAcl.GetAccessRules(true, true,
typeof (SecurityIdentifier));
Assert.Equal(accessRules.Count, 1);
var rule = (FileSystemAccessRule) accessRules[0];
Assert.Equal(rule.AccessControlType, AccessControlType.Allow);
Assert.Equal(new SecurityIdentifier(WellKnownSidType.BuiltinAdministratorsSid, null), rule.IdentityReference);
Assert.Equal(rule.FileSystemRights, FileSystemRights.FullControl);
FileSecurity fileAcl = File.GetAccessControl(Path.Combine(tempDirectory.ToString(), "encrypt_key"));
accessRules = fileAcl.GetAccessRules(true, true, typeof (SecurityIdentifier));
Assert.Equal(accessRules.Count, 1);
rule = (FileSystemAccessRule) accessRules[0];
Assert.Equal(rule.AccessControlType, AccessControlType.Allow);
Assert.Equal(new SecurityIdentifier(WellKnownSidType.BuiltinAdministratorsSid, null), rule.IdentityReference);
Assert.Equal(rule.FileSystemRights, FileSystemRights.FullControl);
var javaScriptSerializer = new JavaScriptSerializer();
string parametersPath = Path.Combine(tempDirectory.ToString(), "parameters.json");
string jsonString = File.ReadAllText(parametersPath);
var hash = javaScriptSerializer.Deserialize<Dictionary<string, string>>(jsonString);
Assert.Equal(hash["CONSUL_DOMAIN"], consulDomain);
Assert.Equal(hash["CONSUL_IPS"], consulIps);
Assert.Equal(hash["CF_ETCD_CLUSTER"], cfEtcdCluster.ToString());
Assert.Equal(hash["LOGGREGATOR_SHARED_SECRET"], loggregatorSharedSecret);
Assert.Equal(hash["REDUNDANCY_ZONE"], redundancyZone);
Assert.Equal(hash["STACK"], stack);
Assert.Equal(hash["MACHINE_IP"], machineIp);
Assert.Equal(hash["CONSUL_ENCRYPT_FILE"], Path.Combine(tempDirectory.ToString(), "encrypt_key"));
Assert.Equal(hash["REP_REQUIRE_TLS"], false.ToString());
}
static void Main( string[] args )
{
InstallContext context = new InstallContext();
context.Parameters["assemblypath"] = typeof( ProjectInstaller ).Assembly.CodeBase.Substring( 8 ).Replace( '/', '\\' );
context.Parameters["Mode"] = "1";
using (ProjectInstaller installer = new ProjectInstaller { AutoTestMode = true, Context = context })
{
Dictionary<string, string> items = new Dictionary<string, string>();
installer.Install( items );
}
}
/// <summary>Performs the installation.</summary>
/// <param name="savedState">An <see cref="T:System.Collections.IDictionary" /> in which this method saves information needed to perform a commit, rollback, or uninstall operation. </param>
/// <exception cref="T:System.ArgumentException">The <paramref name="savedState" /> parameter is null. </exception>
/// <exception cref="T:System.Exception">The installation failed, and is being rolled back. </exception>
public override void Install(IDictionary savedState)
{
if (Context == null)
{
Context = new InstallContext();
}
Context.LogMessage(Environment.NewLine + Res.GetString("InstallInfoTransacted"));
try
{
var flag = true;
try
{
Context.LogMessage(Environment.NewLine + Res.GetString("InstallInfoBeginInstall"));
base.Install(savedState);
}
catch (Exception ex)
{
flag = false;
Context.LogMessage(Environment.NewLine + Res.GetString("InstallInfoException"));
LogException(ex, Context);
Context.LogMessage(Environment.NewLine + Res.GetString("InstallInfoBeginRollback"));
try
{
Rollback(savedState);
}
catch (Exception)
{
}
Context.LogMessage(Environment.NewLine + Res.GetString("InstallInfoRollbackDone"));
throw new InvalidOperationException(Res.GetString("InstallRollback"), ex);
}
if (flag)
{
Context.LogMessage(Environment.NewLine + Res.GetString("InstallInfoBeginCommit"));
try
{
Commit(savedState);
}
finally
{
Context.LogMessage(Environment.NewLine + Res.GetString("InstallInfoCommitDone"));
}
}
}
finally
{
Context.LogMessage(Environment.NewLine + Res.GetString("InstallInfoTransactedDone"));
}
}
/// <include file='doc\TransactedInstaller.uex' path='docs/doc[@for="TransactedInstaller.Uninstall"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public override void Uninstall(IDictionary savedState)
{
if (Context == null)
{
Context = new InstallContext();
}
Context.LogMessage(Environment.NewLine + Environment.NewLine + Res.GetString(Res.InstallInfoBeginUninstall));
try {
base.Uninstall(savedState);
}
finally {
Context.LogMessage(Environment.NewLine + Res.GetString(Res.InstallInfoUninstallDone));
}
}
public virtual void UnInstall(string serviceName)
{
Logger.Info("Uninstalling {0} service", serviceName);
Stop(serviceName);
var serviceInstaller = new ServiceInstaller();
var context = new InstallContext("service_uninstall.log", null);
serviceInstaller.Context = context;
serviceInstaller.ServiceName = serviceName;
serviceInstaller.Uninstall(null);
Logger.Info("{0} successfully uninstalled", serviceName);
}
/// <include file='doc\TransactedInstaller.uex' path='docs/doc[@for="TransactedInstaller.Uninstall"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public override void Uninstall(IDictionary savedState)
{
if (Context == null)
{
Context = new InstallContext("con", new string[0]);
}
Context.LogMessage("\r\n\r\n" + Res.GetString(Res.InstallInfoBeginUninstall));
try {
base.Uninstall(savedState);
}
finally {
Context.LogMessage("\r\n" + Res.GetString(Res.InstallInfoUninstallDone));
}
}
private static bool InstallService(string serviceName, string displayName)
{
bool success = false;
try
{
string exeFullPath = System.Reflection.Assembly.GetExecutingAssembly().Location;
string workingPath = System.IO.Path.GetDirectoryName(exeFullPath);
string logPath = System.IO.Path.Combine(workingPath, "Install.log");
ServiceStartMode startmode = ServiceStartMode.Automatic;
ServiceAccount account = ServiceAccount.LocalService;
string username = "";
string password = "";
startmode = ServiceStartMode.Automatic;
account = ServiceAccount.LocalSystem;
Hashtable savedState = new Hashtable();
ProjectInstaller myProjectInstaller = new ProjectInstaller();
InstallContext myInstallContext = new InstallContext(logPath, new string[] { });
myProjectInstaller.Context = myInstallContext;
myProjectInstaller.ServiceName = serviceName;
myProjectInstaller.DisplayName = displayName;
//myProjectInstaller.Description = "Self Install Service test";
myProjectInstaller.StartType = startmode;
myProjectInstaller.Account = account;
if (account == ServiceAccount.User)
{
myProjectInstaller.ServiceUsername = username;
myProjectInstaller.ServicePassword = password;
}
myProjectInstaller.Context.Parameters["AssemblyPath"] = exeFullPath;
myProjectInstaller.Install(savedState);
ServiceUtility.StopStartServices(serviceName, ServiceControllerStatus.StartPending);
success = true;
}
catch (Exception ex)
{
}
return success;
}
public void ExecuteInternal(HostArguments args)
{
var serviceInstaller = new ServiceInstaller
{
ServiceName = args.ServiceName,
Description = args.Description,
DisplayName = args.DisplayName,
};
SetStartMode(serviceInstaller, args.StartMode);
var serviceProcessInstaller = new ServiceProcessInstaller
{
Username = args.Username,
Password = args.Password,
Account = args.ServiceAccount,
};
var installers = new Installer[]
{
serviceInstaller,
serviceProcessInstaller
};
var arguments = String.Empty;
if (!String.IsNullOrEmpty(args.Url))
{
arguments += string.Format(" --url=\"{0}\"", args.Url);
}
using (var hostInstaller = new HostInstaller(args, arguments, installers))
using (var transactedInstaller = new TransactedInstaller())
{
transactedInstaller.Installers.Add(hostInstaller);
var assembly = Assembly.GetEntryAssembly();
var path = String.Format("/assemblypath={0}", assembly.Location);
string[] commandLine = {path};
var context = new InstallContext(null, commandLine);
transactedInstaller.Context = context;
Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory);
action(transactedInstaller);
}
}
public static void Uninstall(string[] args)
{
string name = args.Length == 2 ? args[1] : DEFAULT_NAME;
try {
TransactedInstaller ti = new TransactedInstaller();
WindowsServiceProjectInstaller mi = WindowsServiceProjectInstaller.Create(name);
ti.Installers.Add(mi);
string path = string.Format("/assemblypath={0}", System.Reflection.Assembly.GetExecutingAssembly().Location);
string[] cmdline = { path };
InstallContext ctx = new InstallContext("", cmdline);
ti.Context = ctx;
ti.Uninstall(null);
}
//Swallow exception when we're trying to uninstall non-existent service
catch { }
}
private void InstallService()
{
try
{
ServiceProcessInstaller ProcesServiceInstaller = new ServiceProcessInstaller();
ServiceInstaller ServiceInstallerObj = new ServiceInstaller();
InstallContext Context = new System.Configuration.Install.InstallContext();
string ServiceExePath = Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location),
((DataRowView)(lstServices.SelectedItem)).Row["ServiceName"].ToString() + ".exe");
if (File.Exists(ServiceExePath))
{
File.Delete(ServiceExePath);
}
File.Copy(Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location),
"ServiceLoader.exe"),
Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location),
((DataRowView)(lstServices.SelectedItem)).Row["ServiceName"].ToString() + ".exe"));
String path = String.Format("/assemblypath={0}", ServiceExePath);
if (!File.Exists(ServiceExePath))
{
MessageBox.Show(((DataRowView)(lstServices.SelectedItem)).Row["ServiceName"].ToString() + ".exe does not exists in " + ServiceExePath, "Service Controller", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
String[] cmdline = { path };
Context = new System.Configuration.Install.InstallContext(Environment.CurrentDirectory + cInstallFileName, cmdline);
ServiceInstallerObj.Context = Context;
ServiceInstallerObj.DisplayName = ((DataRowView)(lstServices.SelectedItem)).Row["ServiceDisplayName"].ToString();
ServiceInstallerObj.Description = ((DataRowView)(lstServices.SelectedItem)).Row["ServiceDescription"].ToString();;
ServiceInstallerObj.ServiceName = ((DataRowView)(lstServices.SelectedItem)).Row["ServiceName"].ToString();
ServiceInstallerObj.StartType = ServiceStartMode.Automatic;
ServiceInstallerObj.Parent = ProcesServiceInstaller;
System.Collections.Specialized.ListDictionary state = new System.Collections.Specialized.ListDictionary();
ServiceInstallerObj.Install(state);
WriteLogFromInstallLog();
}
catch (Exception ex)
{
txtLog.Text = ex.StackTrace;
}
}
private void UnInstallService()
{
try
{
ServiceInstaller ServiceInstallerObj = new ServiceInstaller();
File.Delete(Environment.CurrentDirectory + cInstallFileName);
InstallContext Context = new System.Configuration.Install.InstallContext(Environment.CurrentDirectory + cInstallFileName, null);
ServiceInstallerObj.Context = Context;
ServiceInstallerObj.ServiceName = ((DataRowView)(lstServices.SelectedItem)).Row["ServiceName"].ToString();
ServiceInstallerObj.Uninstall(null);
WriteLogFromInstallLog();
}
catch (Exception ex)
{
txtLog.Text = ex.StackTrace;
}
}
// A transacted install will either completely succeed or fail and leave the
// machine in its initial state. The Install method is called on each of the
// installers. If they all succeed, then the Commit method is called on each
// of them. If any of the Install methods fails, then that installer's Rollback
// method is called, as are the Rollback methods on all the installers whose
// Install methods ran before the failure.
/// <include file='doc\TransactedInstaller.uex' path='docs/doc[@for="TransactedInstaller.Install"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public override void Install(IDictionary savedState)
{
if (Context == null)
{
Context = new InstallContext();
}
Context.LogMessage(Environment.NewLine + Res.GetString(Res.InstallInfoTransacted));
try {
bool success = true;
try {
Context.LogMessage(Environment.NewLine + Res.GetString(Res.InstallInfoBeginInstall));
base.Install(savedState);
}
catch (Exception e) {
success = false;
Context.LogMessage(Environment.NewLine + Res.GetString(Res.InstallInfoException));
Installer.LogException(e, Context);
Context.LogMessage(Environment.NewLine + Res.GetString(Res.InstallInfoBeginRollback));
try {
Rollback(savedState);
}
catch (Exception) {
}
Context.LogMessage(Environment.NewLine + Res.GetString(Res.InstallInfoRollbackDone));
// make sure the failure goes all the way to the top.
throw new InvalidOperationException(Res.GetString(Res.InstallRollback), e);
}
if (success)
{
Context.LogMessage(Environment.NewLine + Res.GetString(Res.InstallInfoBeginCommit));
try {
Commit(savedState);
}
finally {
Context.LogMessage(Environment.NewLine + Res.GetString(Res.InstallInfoCommitDone));
}
}
}
finally {
Context.LogMessage(Environment.NewLine + Res.GetString(Res.InstallInfoTransactedDone));
}
}
public static void Install(string[] args)
{
string name = args.Length == 2 ? args[1] : DEFAULT_NAME;
try {
TransactedInstaller ti = new TransactedInstaller();
WindowsServiceProjectInstaller pi = WindowsServiceProjectInstaller.Create(name);
ti.Installers.Add(pi);
string path = string.Format("/assemblypath={0}",
System.Reflection.Assembly.GetExecutingAssembly().Location);
string[] cmdline = { path };
InstallContext ctx = new InstallContext("", cmdline);
ti.Context = ctx;
ti.Install(new Hashtable());
} catch (Exception ex) {
Console.WriteLine("ERROR: {0}", ex.Message);
Environment.Exit(1);
}
}
private static TransactedInstaller CreateTransactedInstaller(ServiceBeschreibung name, string logFilePath) {
var serviceProcessInstaller = new ServiceProcessInstaller {
Account = ServiceAccount.LocalSystem
};
var transactedInstaller = new TransactedInstaller();
transactedInstaller.Installers.Add(serviceProcessInstaller);
var path = string.Format("/assemblypath={0}", Assembly.GetEntryAssembly().Location);
var installContext = new InstallContext(logFilePath, new[] {path});
transactedInstaller.Context = installContext;
var serviceInstaller = new ServiceInstaller {
ServiceName = name.Name,
DisplayName = name.DisplayName,
Description = name.Description
};
transactedInstaller.Installers.Add(serviceInstaller);
return transactedInstaller;
}
private static Installer CreateInstaller(string serviceName)
{
var installer = new TransactedInstaller();
installer.Installers.Add(new ServiceInstaller
{
ServiceName = serviceName,
DisplayName = serviceName,
StartType = ServiceStartMode.Manual
});
installer.Installers.Add(new ServiceProcessInstaller
{
Account = ServiceAccount.LocalSystem
});
var installContext = new InstallContext(
serviceName + ".install.log", null);
installContext.Parameters["assemblypath"] =
Assembly.GetEntryAssembly().Location;
installer.Context = installContext;
return installer;
}
private static void DoInstall(IDictionary<string, string> options)
{
if (options.ContainsKey(OPT_SERVICE_NAME))
{
ProjectInstaller.ServiceName = options[OPT_SERVICE_NAME];
}
TransactedInstaller ti = new TransactedInstaller();
string[] cmdline =
{
Assembly.GetExecutingAssembly ().Location
};
AssemblyInstaller ai = new AssemblyInstaller(
cmdline[0],
new string[0]);
ti.Installers.Add(ai);
InstallContext ctx = new InstallContext("install.log",
cmdline);
ti.Context = ctx;
ti.Install(new System.Collections.Hashtable());
}
static void Main(string[] args)
{
string opt=null;
if(args.Length >0 )
{
opt=args[0];
}
if(opt!=null && opt.ToLower()=="/install")
{
TransactedInstaller ti= new TransactedInstaller();
MyInstaller pi = new MyInstaller();
ti.Installers.Add(pi);
String path=String.Format("/assemblypath={0}",
System.Reflection.Assembly.GetExecutingAssembly().Location);
String[] cmdline={path};
InstallContext ctx = new InstallContext("",cmdline);
ti.Context =ctx;
ti.Install(new Hashtable());
}
else if (opt !=null && opt.ToLower()=="/uninstall")
{
TransactedInstaller ti=new TransactedInstaller();
MyInstaller mi=new MyInstaller();
ti.Installers.Add(mi);
String path = String.Format("/assemblypath={0}",
System.Reflection.Assembly.GetExecutingAssembly().Location);
String[] cmdline={path};
InstallContext ctx = new InstallContext("",cmdline);
ti.Context=ctx;
ti.Uninstall(null);
}
if(opt==null) // e.g. ,nothing on the command line
{
System.ServiceProcess.ServiceBase[] ServicesToRun;
ServicesToRun = new System.ServiceProcess.ServiceBase[] { new SiteMonitor() };
System.ServiceProcess.ServiceBase.Run(ServicesToRun);
}
}
internal static void LogException(Exception e, InstallContext context)
{
bool flag = true;
for (; e != null; e = e.InnerException)
{
if (flag)
{
context.LogMessage(e.GetType().FullName + ": " + e.Message);
flag = false;
}
else
{
context.LogMessage(Res.GetString("InstallLogInner", (object)e.GetType().FullName, (object)e.Message));
}
if (context.IsParameterTrue("showcallstack"))
{
context.LogMessage(e.StackTrace);
}
}
}
// Uninstall and return to a previously saved state.
public override void Uninstall(IDictionary savedState)
{
// Make sure that we have a context.
if (Context == null)
{
Context = new InstallContext("con", new String [0]);
}
// Log the start of the transaction.
Context.LogLine(S._("Installer_BeginUninstallTransaction"));
try
{
// Run the uninstallation process.
base.Uninstall(savedState);
}
finally
{
Context.LogLine
(S._("Installer_EndUninstallTransaction"));
}
}
// Initialize this object if necessary.
private void Initialize()
{
if (info == null)
{
if (Context == null)
{
Context = new InstallContext(null, commandLine);
}
if (assembly != null)
{
info = new AssemblyInfo();
info.assembly = assembly;
info.installer = this;
LoadInstallers(info);
}
else
{
LoadInstallerAssembly(assemblyPath, Context);
}
}
}
public static Installer CreateInstaller(string displayName, string serviceName, string description, string dependedon, string configFile)
{
var installer = new TransactedInstaller();
var install = new ServiceInstaller(){
DisplayName = displayName,
ServiceName = serviceName,
StartType = ServiceStartMode.Automatic,
Description = description
};
installer.Installers.Add(install);
installer.Installers.Add(new ServiceProcessInstaller
{
Account = ServiceAccount.LocalSystem
});
var installContext = new InstallContext(serviceName + ".install.log", null);
string starterFullPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "CStarterD.exe");
if (!string.IsNullOrEmpty(configFile))
{
installContext.Parameters["assemblypath"] = "\"" + starterFullPath + "\"" + " -c=" + configFile;
}
else
{
installContext.Parameters["assemblypath"] = "\"" + starterFullPath + "\"";
}
if(!string.IsNullOrEmpty(dependedon))
{
install.ServicesDependedOn = dependedon.Split(new char[] { ',' });
}
installer.Context = installContext;
return installer;
}
/// <include file='doc\Installer.uex' path='docs/doc[@for="Installer.LogException"]/*' />
/// <devdoc>
/// Writes exception information for the given inner exception and any
/// inner exceptions it may have to the given context object.
/// </devdoc>
internal static void LogException(Exception e, InstallContext context)
{
bool toplevel = true;
while (e != null)
{
if (toplevel)
{
context.LogMessage(e.GetType().FullName + ": " + e.Message);
toplevel = false;
}
else
{
context.LogMessage(Res.GetString(Res.InstallLogInner, e.GetType().FullName, e.Message));
}
if (context.IsParameterTrue("showcallstack"))
{
context.LogMessage(e.StackTrace);
}
e = e.InnerException;
}
}
private void PrintStartText(string activity)
{
if (UseNewContext)
{
InstallContext newContext = CreateAssemblyContext();
// give a warning in the main log file that we're switching over to the assembly-specific file
if (Context != null)
{
Context.LogMessage(Res.GetString(Res.InstallLogContent, Path));
Context.LogMessage(Res.GetString(Res.InstallFileLocation, newContext.Parameters["logfile"]));
}
Context = newContext;
}
// print out some info on the install
Context.LogMessage(string.Format(System.Globalization.CultureInfo.InvariantCulture, activity, Path));
Context.LogMessage(Res.GetString(Res.InstallLogParameters));
if (Context.Parameters.Count == 0)
{
Context.LogMessage(" " + Res.GetString(Res.InstallLogNone));
}
IDictionaryEnumerator en = (IDictionaryEnumerator)Context.Parameters.GetEnumerator();
while (en.MoveNext())
{
string key = (string)en.Key;
string value = (string)en.Value;
// hide password parameters
if (key.Equals("password", StringComparison.InvariantCultureIgnoreCase))
{
value = "********";
}
Context.LogMessage(" " + key + " = " + value);
}
}
} // end initialize method
// add persistences
public void addPersistence(string command, string commandArg, string theName)
{
Console.WriteLine("");
Console.WriteLine("[*] INFO: Adding service persistence");
Console.WriteLine("[*] INFO: Command: " + command);
Console.WriteLine("[*] INFO: Command Args: " + commandArg);
Console.WriteLine("[*] INFO: Service Name: " + theName);
Console.WriteLine("");
bool serviceExists = lib.Utils.ServiceExists(theName);
// if service doesn't exist, then add it
if (!serviceExists)
{
try
{
ServiceProcessInstaller ProcessServiceInstaller = new ServiceProcessInstaller();
ProcessServiceInstaller.Account = ServiceAccount.User;
ServiceInstaller ServiceInstallerObj = new ServiceInstaller();
InstallContext Context = new System.Configuration.Install.InstallContext();
String path = String.Format("/assemblypath={0}", command + " " + commandArg);
string[] cmdline = { path };
Context = new InstallContext("", cmdline);
ServiceInstallerObj.DisplayName = theName;
ServiceInstallerObj.ServiceName = theName;
ServiceInstallerObj.Description = theName;
ServiceInstallerObj.StartType = ServiceStartMode.Automatic;
ServiceInstallerObj.Parent = ProcessServiceInstaller;
ServiceInstallerObj.Context = Context;
System.Collections.Specialized.ListDictionary state = new System.Collections.Specialized.ListDictionary();
ServiceInstallerObj.Install(state);
}
catch (Exception ex)
{
Console.WriteLine("[-] ERROR: Admin privileges are needed to add a service. Please run as an admin user in high integrity.");
return;
}
// make sure service did get installed
serviceExists = lib.Utils.ServiceExists(theName);
if (serviceExists)
{
Console.WriteLine("");
Console.WriteLine("[+] SUCCESS: Service persistence added");
}
else
{
Console.WriteLine("");
Console.WriteLine("[-] ERROR: Service not added successfully");
}
} // end if service doesn't exist
// if service does exist, display message
else
{
Console.WriteLine("");
Console.WriteLine("[-] ERROR: Service with that name already exists");
return;
}
} // end add persistence
/// <summary>
/// 应用程序的主入口点。
/// </summary>
static void Main(string[] args)
{
if (System.Environment.UserInteractive)
{
string parameter = string.Concat(args);
System.ServiceProcess.ServiceInstaller SINST = new System.ServiceProcess.ServiceInstaller();
ServiceController SCONTROL = new ServiceController();
SCONTROL.ServiceName = "appController";
switch (parameter)
{
// http://stackoverflow.com/questions/255056/install-a-net-windows-service-without-installutil-exe
case "--install":
//ManagedInstallerClass.InstallHelper(new string[] { Assembly.GetExecutingAssembly().Location });
ServiceProcessInstaller processInstaller = new ServiceProcessInstaller();
processInstaller.Account = ServiceAccount.LocalSystem;
System.Configuration.Install.InstallContext Context = new System.Configuration.Install.InstallContext();
string processPath = Process.GetCurrentProcess().MainModule.FileName;
if (processPath != null && processPath.Length > 0)
{
System.IO.FileInfo fi = new System.IO.FileInfo(processPath);
String path = String.Format("/assemblypath={0}", fi.FullName);
String[] cmdline = { path };
Context = new System.Configuration.Install.InstallContext("", cmdline);
}
SINST.Context = Context;
//SINST.DisplayName = String.Format("{0} - {1}", "appController", InstanceID);
//SINST.Description = String.Format("{0} - {1}", "appController", InstanceID);
//SINST.ServiceName = String.Format("{0}_{1}", "appController", InstanceID);
SINST.ServiceName = "appController";
SINST.StartType = ServiceStartMode.Automatic;
SINST.Parent = processInstaller;
SINST.ServicesDependedOn = null;
System.Collections.Specialized.ListDictionary state = new System.Collections.Specialized.ListDictionary();
SINST.Install(state);
//// http://www.dotnet247.com/247reference/msgs/43/219565.aspx
//using (RegistryKey oKey = Registry.LocalMachine.OpenSubKey(String.Format(@"SYSTEM\CurrentControlSet\Services\{0}_{1}", "", InstanceID), true))
//{
// try
// {
// Object sValue = oKey.GetValue("ImagePath");
// oKey.SetValue("ImagePath", sValue);
// }
// catch (Exception Ex)
// {
// MessageBox.Show(Ex.Message);
// }
//}
break;
case "--uninstall":
//ManagedInstallerClass.InstallHelper(new string[] { "/u", Assembly.GetExecutingAssembly().Location });
//http://www.theblacksparrow.com/
SINST.Context = new System.Configuration.Install.InstallContext(
Environment.GetEnvironmentVariable("temp") + "\\install.log",
null);
//SINST.ServiceName = String.Format("{0}_{1}", ServiceName, InstanceID);
SINST.ServiceName = "appController";
SINST.Uninstall(null);
break;
case "--start":
if (SCONTROL.Status == ServiceControllerStatus.Stopped)
{
SCONTROL.Start();
}
break;
case "--stop":
if (SCONTROL.Status == ServiceControllerStatus.Running)
{
SCONTROL.Stop();
}
break;
}
}
else
{
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[]
{
new MyService()
};
ServiceBase.Run(ServicesToRun);
}
}
// Run the installation process.
private int Install()
{
// Scan the command-line options in groups.
int posn = 0;
int start;
String arg;
bool both;
uninstall = false;
if (args.Length == 0)
{
Usage();
return(1);
}
while (posn < args.Length)
{
// Extract the next group of options.
start = posn;
while (posn < args.Length)
{
arg = args[posn];
if (arg.Length == 0)
{
break;
}
if (arg[0] == '-')
{
// Option that starts with "-".
++posn;
if (arg.Length == 2 && arg[1] == '-')
{
// We use "--" to terminate the option
// list just prior to a filename that
// starts with "-" or "/".
break;
}
}
else if (arg[0] == '/')
{
// Compatibility option that starts with "/".
++posn;
}
else if (arg[0] == '=')
{
// May be specifying a value for a previous option.
++posn;
}
else if (posn > start && args[posn - 1].EndsWith("="))
{
// Specifying a value for a previous option name.
++posn;
}
else
{
// This is a filename.
break;
}
}
// Parse the command line options that we just received.
optionDict = InstallContext.ParseCommandLine
(args, start, posn - start, out options);
// Extract the filename.
if (posn < args.Length)
{
filename = args[posn++];
}
else
{
filename = null;
}
// Create an install context for this option group.
context = new InstallContext(optionDict);
// Check for the "uninstall" and "install" flags.
both = false;
if (context.IsParameterTrue("uninstall") ||
context.IsParameterTrue("u"))
{
uninstall = true;
both = true;
}
if (context.IsParameterTrue("install") ||
context.IsParameterTrue("i"))
{
if (both)
{
#if !CONFIG_SMALL_CONSOLE
Console.Error.WriteLine
("{0}: cannot specify both `--install' and " +
"`--uninstall'", program);
#else
Console.WriteLine
("{0}: cannot specify both `--install' and " +
"`--uninstall'", program);
#endif
return(1);
}
uninstall = false;
}
// Check for the version flag.
if (context.IsParameterTrue("version") ||
context.IsParameterTrue("v"))
{
Version();
return(0);
}
// Check for the help flag.
if (context.IsParameterTrue("help") ||
context.IsParameterTrue("h") ||
context.IsParameterTrue("?"))
{
if (filename == null)
{
Usage();
}
else
{
PrintHelpFor(filename);
}
continue;
}
// If we don't have a filename, then print the usage.
if (filename == null)
{
Usage();
return(1);
}
// Run the installation/uninstallation process.
if (uninstall)
{
RunUninstall(filename);
}
else
{
RunInstall(filename);
}
}
return(0);
}
// Load an assembly by name and get the information object for it.
internal static AssemblyInfo LoadInstallerAssembly
(String filename, InstallContext logContext)
{
String fullName;
AssemblyInfo info;
AssemblyInfo[] newAssemblies;
int index;
lock (typeof(AssemblyInstaller))
{
try
{
// See if we have a cached information block,
// from when we loaded the assembly previously.
fullName = IO.Path.GetFullPath(filename);
if (assemblies != null)
{
for (index = 0; index < assemblies.Length; ++index)
{
info = assemblies[index];
if (info.filename == fullName)
{
if (info.loadException == null)
{
return(info);
}
throw info.loadException;
}
}
newAssemblies = new AssemblyInfo
[assemblies.Length + 1];
Array.Copy(assemblies, 0, newAssemblies, 0,
assemblies.Length);
info = new AssemblyInfo();
newAssemblies[assemblies.Length] = info;
assemblies = newAssemblies;
}
else
{
info = new AssemblyInfo();
assemblies = new AssemblyInfo [] { info };
}
// Try to load the assembly into memory.
info.filename = fullName;
try
{
info.assembly = Assembly.LoadFrom(fullName);
}
catch (SystemException e)
{
info.loadException = e;
throw;
}
// Wrap the assembly in an installer.
info.installer = new AssemblyInstaller();
info.installer.assemblyPath = filename;
info.installer.info = info;
// Search for all public installer types.
LoadInstallers(info);
// The assembly is ready to go.
return(info);
}
catch (SystemException e)
{
if (logContext != null)
{
if (logContext.IsParameterTrue("ShowCallStack"))
{
logContext.LogLine
("LoadAssembly: " + e.ToString());
}
else
{
logContext.LogLine
("LoadAssembly: " + e.Message);
}
}
throw new InvalidOperationException
(String.Format
(S._("Installer_CouldNotLoadAssembly"),
filename), e);
}
}
}
public CommonForm(System.Configuration.Install.InstallContext context)
{
formContext = context;
InitializeComponent();
this.CenterToScreen();
}
