Beispiel #1
1
        public void All_environment_variables_from_spec_are_available_as_typed_properties()
        {
            var headers = new Dictionary<string, string>();
            var body = new BodyDelegate((next, error, complete) => () => { }).ToAction();

            var env = new Dictionary<string, object>
            {
                {"owin.RequestMethod", "GET"},
                {"owin.RequestPath", "/foo"},
                {"owin.RequestHeaders", headers},
                {"owin.RequestBody", body},
                {"owin.RequestPathBase", "/my-app"},
                {"owin.RequestQueryString", "hello=world"},
                {"owin.RequestScheme", "https"},
                {"owin.Version", "1.0"},
            };

            var environment = new Environment(env);
            Assert.That(environment.Method, Is.EqualTo("GET"));
            Assert.That(environment.Path, Is.EqualTo("/foo"));
            Assert.That(environment.Headers, Is.SameAs(headers));
            Assert.That(environment.Body, Is.SameAs(body));
            Assert.That(environment.PathBase, Is.EqualTo("/my-app"));
            Assert.That(environment.QueryString, Is.EqualTo("hello=world"));
            Assert.That(environment.Scheme, Is.EqualTo("https"));
            Assert.That(environment.Version, Is.EqualTo("1.0"));
        }
        public async Task<MiddlewareInvocationEnum> Invoke(Environment environment)
        {
            string[] setReplyHeader;
            bool shouldSetReply = false;

            if (environment.RequestHeaders.TryGetValue(SET_REPLY_HEADER_NAME, out setReplyHeader)
                && !string.IsNullOrWhiteSpace(setReplyHeader[0])
                && bool.TryParse(setReplyHeader[0], out shouldSetReply)
                && shouldSetReply)
            {
                Replies[environment.RequestPath] = await ReadAllBytes(environment.RequestBody);

                return MiddlewareInvocationEnum.StopChain;
            }
            else
            {
                byte[] data;

                if (Replies.TryGetValue(environment.RequestPath, out data))
                {
                    await environment.ResponseBody.WriteAsync(data, 0, data.Length);

                    environment.ResponseHeaders.ContentLength = data.Length;
                    environment.ResponseHeaders.ContentType = "application/json";

                    return MiddlewareInvocationEnum.StopChain;
                }
                else
                    return MiddlewareInvocationEnum.ContinueToNext;
            }
        }
 public void TestAndConditionBlocked()
 {
     var env = new Environment();
       env.Process(TestAndConditionBlockedProcess(env));
       env.RunD(5);
       Assert.AreEqual(5, env.NowD);
 }
 public ObstacleBuilder(Environment e)
 {
     InitializeComponent();
     env = e;
     Pass = radioPassYes.Checked;
     Dyn = radioDynYes.Checked;
 }
        private IEnumerable<Event> Customer(Environment env, string name, Resource counter, TimeSpan meanTimeInBank)
        {
            var arrive = env.Now;

              env.Log("{0} {1}: Here I am", arrive, name);

              using (var req = counter.Request()) {
            // Wait for the counter or abort at the end of our tether
            var timeout = env.TimeoutUniform(MinPatience, MaxPatience);
            yield return req | timeout;

            var wait = env.Now - arrive;

            if (req.IsProcessed) {
              // We got the counter
              env.Log("{0} {1}: waited {2}", env.Now, name, wait);

              yield return env.TimeoutExponential(meanTimeInBank);
              env.Log("{0} {1}: Finished", env.Now, name);
            } else {
              // We reneged
              env.Log("{0} {1}: RENEGED after {2}", env.Now, name, wait);
            }
              }
        }
        private IEnumerable<Event> Car(string name, Environment env, Resource gasStation, Container fuelPump)
        {
            /*
               * A car arrives at the gas station for refueling.
               *
               * It requests one of the gas station's fuel pumps and tries to get the
               * desired amount of gas from it. If the stations reservoir is
               * depleted, the car has to wait for the tank truck to arrive.
               */
              var fuelTankLevel = env.RandUniform(MinFuelTankLevel, MaxFuelTankLevel + 1);
              env.Log("{0} arriving at gas station at {1}", name, env.Now);
              using (var req = gasStation.Request()) {
            var start = env.Now;
            // Request one of the gas pumps
            yield return req;

            // Get the required amount of fuel
            var litersRequired = FuelTankSize - fuelTankLevel;
            yield return fuelPump.Get(litersRequired);

            // The "actual" refueling process takes some time
            yield return env.Timeout(TimeSpan.FromSeconds(litersRequired / RefuelingSpeed));

            env.Log("{0} finished refueling in {1} seconds.", name, (env.Now - start).TotalSeconds);
              }
        }
Beispiel #7
1
        public static void Main(string[] args)
        {
            // Change the console window
            Terminal term = new Terminal();
            term.Title = "Terminal Window Title";
            term.DisplayMode = (int)ConsoleDisplayModeForSet.CONSOLE_FULLSCREEN_MODE;

            //Console.WriteLine("Terminal Title: {0}", term.Title);
            term.WriteLine("Terminal Window Title - has been set");
            COORD fontSize = term.FontSize;
            Console.WriteLine("Terminal Font Size: X = {0}, Y = {1}", fontSize.X, fontSize.Y);
            Console.WriteLine("mouse buttons: {0}", term.MouseButtons);

            // Instantiate a machine
            Machine aMachine = new Machine();

            // Print some properties
            Console.WriteLine("Name: {0}", aMachine.ShortName);
            Console.WriteLine("Domain: {0}", aMachine.DomainName);

            Environment environ = new Environment();
            Console.WriteLine("Command Line: {0}", environ.CommandLine);

            // Get the name of the process image that this process is running
            //Process aProc = new Process();
            //PrintProcess(aProc);
            //PrintAllProcesses();

            PrintAllDrives();
            //PrintVolumes();

            Console.ReadLine();
        }
Beispiel #8
1
        /// <summary>
        /// Creates instance of LISpMiner for existing location.
        /// </summary>
        /// <param name="lmpath">Path to LM folder.</param>
        /// <param name="env">Environment settings.</param>
        public LISpMiner(DirectoryInfo lmpath, Environment env)
        {
            if (!lmpath.Exists)
            {
                throw new Exception(String.Format("LISpMiner does not exist at location {0}", lmpath.FullName));
            }

            this.Environment = env;
            this.Id = lmpath.Name.Substring("LISpMiner_".Length);
            this.LMPrivatePath = lmpath.FullName;

            this.SharedPool = !File.Exists(Path.Combine(this.LMPrivatePath, "LMTaskPooler.exe"));

            string metabaseFile;
            string devNull = string.Empty;
            string metabaseDSNFile;
            string databaseFile;
            string databaseDSNFile;

            this.GetDatabaseNames(string.Empty, out databaseFile, out databaseDSNFile);

            if (File.Exists(databaseFile))
            {
                this.Database = new AccessConnection(databaseDSNFile, databaseFile, string.Empty);
            }
            else
            {
                this.Database = new MySQLConnection(databaseDSNFile);
            }

            this.GetMetabaseNames(out metabaseFile, ref devNull, out metabaseDSNFile);
            this.Metabase = new AccessConnection(metabaseDSNFile, metabaseFile, string.Empty);

            this.Created = lmpath.CreationTime;
        }
Beispiel #9
1
 /// <summary>Composes a path name of a special folder and a string component</summary>
 public static string Compose(Environment.SpecialFolder special, params string[] components)
 {
     var args = new string[1 + components.Length];
     args[0] = Environment.GetFolderPath(special);
     Array.Copy(components, 0, args, 1, components.Length);
     return Compose(args);
 }
 public override bool EvalStep(out object answer, ref Control expression, ref Environment environment)
 {
     #if DEBUG
     Warm ("PrimitiveIsCharEqA.EvalStep");
     #endif
     throw new NotImplementedException ();
 }
        public override void Update(Environment environment, Camera cam, Mesh mesh)
        {
            base.Update(environment, cam, mesh);
            if (currentMaterial != null)
            {
                Texture diffuseTex = currentMaterial.GetTexture(Material.TEXTURE_DIFFUSE);
                if (diffuseTex != null)
                {
                    Texture.ActiveTextureSlot(0);
                    diffuseTex.Use();
                    SetUniform("Material_DiffuseMap", 0);
                    SetUniform("Material_HasDiffuseMap", 1);
                }
                else
                {
                    SetUniform("Material_HasDiffuseMap", 0);
                }

                Texture normalTex = currentMaterial.GetTexture(Material.TEXTURE_NORMAL);
                if (normalTex != null)
                {
                    Texture.ActiveTextureSlot(1);
                    normalTex.Use();
                    SetUniform("Material_NormalMap", 1);
                    SetUniform("Material_HasNormalMap", 1);
                }
                else
                {
                    SetUniform("Material_HasNormalMap", 0);
                }
            }
        }
Beispiel #12
1
        public void All_environment_variables_from_spec_are_available_as_typed_properties()
        {
            var headers = new Dictionary<string, string>();
            BodyDelegate body = (next, error, complete) => () => { };

            var env = new Dictionary<string, object>
            {
                {"owin.RequestMethod", "GET"},
                {"owin.RequestUri", "/foo"},
                {"owin.RequestHeaders", headers},
                {"owin.RequestBody", body},
                {"owin.BaseUri", "/my-app"},
                {"owin.ServerName", "localhost"},
                {"owin.ServerPort", "8080"},
                {"owin.UriScheme", "https"},
                {"owin.RemoteEndPoint", new IPEndPoint(IPAddress.Parse("127.0.0.1") ?? IPAddress.None, 80)},
                {"owin.Version", "1.0"},
            };

            var environment = new Environment(env);
            Assert.That(environment.Method, Is.EqualTo("GET"));
            Assert.That(environment.RequestUri, Is.EqualTo("/foo"));
            Assert.That(environment.Headers, Is.SameAs(headers));
            Assert.That(environment.Body, Is.SameAs(body));
            Assert.That(environment.BaseUri, Is.EqualTo("/my-app"));
            Assert.That(environment.ServerName, Is.EqualTo("localhost"));
            Assert.That(environment.ServerPort, Is.EqualTo("8080"));
            Assert.That(environment.UriScheme, Is.EqualTo("https"));
            Assert.That(environment.RemoteEndPoint.ToString(), Is.EqualTo("127.0.0.1:80"));
            Assert.That(environment.Version, Is.EqualTo("1.0"));
        }
Beispiel #13
1
        public void All_environment_variables_from_spec_are_available_as_typed_properties()
        {
            var headers = new Dictionary<string, string[]>();
            BodyDelegate body = (a, b, c) => { };

            var env = new Dictionary<string, object>
            {
                {OwinConstants.RequestMethod, "GET"},
                {OwinConstants.RequestPath, "/foo"},
                {OwinConstants.RequestHeaders, headers},
                {OwinConstants.RequestBody, body},
                {OwinConstants.RequestPathBase, "/my-app"},
                {OwinConstants.RequestQueryString, "hello=world"},
                {OwinConstants.RequestScheme, "https"},
                {OwinConstants.Version, "1.0"},
            };

            var environment = new Environment(env);
            Assert.That(environment.Method, Is.EqualTo("GET"));
            Assert.That(environment.Path, Is.EqualTo("/foo"));
            Assert.That(environment.Headers, Is.SameAs(headers));
            Assert.That(environment.BodyDelegate, Is.SameAs(body));
            Assert.That(environment.PathBase, Is.EqualTo("/my-app"));
            Assert.That(environment.QueryString, Is.EqualTo("hello=world"));
            Assert.That(environment.Scheme, Is.EqualTo("https"));
            Assert.That(environment.Version, Is.EqualTo("1.0"));
        }
        public override bool EvalStep(out object answer, ref Control expression, ref Environment environment)
        {
            #if DEBUG
            Warm ("-");
            NoteCalls (this.rand0);
            NoteCalls (this.rand1);
            rand0TypeHistogram.Note (this.rand0Type);
            rand1TypeHistogram.Note (this.rand1Type);
            SCode.location = "PCondRecordRef";
            #endif
            Control unev = this.rand1;
            Environment env = environment;
            object ev1;
            while (unev.EvalStep (out ev1, ref unev, ref env)) { };
            #if DEBUG
            SCode.location = "PCondRecordRef";
            #endif
            if (ev1 == Interpreter.UnwindStack) {
                throw new NotImplementedException ();
            }

            unev = this.rand0;
            env = environment;
            object ev0;
            while (unev.EvalStep (out ev0, ref unev, ref env)) { };
            #if DEBUG
            SCode.location = "PCondRecordRef";
            #endif
            if (ev0 == Interpreter.UnwindStack) {
                throw new NotImplementedException ();
                //((UnwinderState) env).AddFrame (new PrimitiveCombination1Frame0 (this, environment));
                //answer = Interpreter.UnwindStack;
                //environment = env;
                //return false;
            }

            object result = ((Record) ev0).Ref ((int) ev1);

            if (result is Boolean && (((bool) result) == false)) {
            #if DEBUG
                SCode.location = "-";
                NoteCalls (this.alternative);
                alternativeTypeHistogram.Note (this.alternativeType);
                SCode.location = "PCondRecordRef";
            #endif
                expression = this.alternative;
                answer = null;
                return true;
            } else {
            #if DEBUG
                SCode.location = "-";
                NoteCalls (this.consequent);
                consequentTypeHistogram.Note (this.consequentType);
                SCode.location = "PCondRecordRef";
            #endif
                expression = this.consequent;
                answer = null;
                return true;
            }
        }
        public override bool EvalStep(out object answer, ref Control expression, ref Environment environment)
        {
            #if DEBUG
            Warm ("-");
            NoteCalls (this.rand1);
            rand1TypeHistogram.Note (this.rand1Type);
            SCode.location = "PrimitiveIsCharEqQ";
            #endif
            // Eval argument1
            object ev1;

            Control unev = this.rand1;
            Environment env = environment;
            while (unev.EvalStep (out ev1, ref unev, ref env)) { };
            if (ev1 == Interpreter.UnwindStack) {
                throw new NotImplementedException ();
                //((UnwinderState) env).AddFrame (new PrimitiveCombination2Frame0 (this, environment));
                //answer = Interpreter.UnwindStack;
                //environment = env;
                //return false;
            }
            //bool x = (ev1 is char);
            //bool y = (ev1 is Character);
            //if (x != y) Debugger.Break ();
            answer = ((ev1 is char) && (this.rand0Value == (char) ev1)) ? Constant.sharpT : Constant.sharpF;
            return false;
        }
        public Request(SHA sha, string shaInSignature, string pspID, int orderID, decimal price, Encoding encoding, Environment environment)
        {
            if (string.IsNullOrWhiteSpace(shaInSignature))
            {
                throw new ArgumentException("SHA-IN is required");
            }

            if (string.IsNullOrWhiteSpace(pspID))
            {
                throw new ArgumentException("PSPID is required");
            }

            if (orderID < 1)
            {
                throw new ArgumentException("Invalid Order ID");
            }

            if (price <= 0)
            {
                throw new ArgumentException("Invalid price");
            }

            this._sha = sha;
            this._shaInSignature = shaInSignature;
            this._pspID = pspID;
            this._orderID = orderID;
            this._price = price;
            extrafields = new Dictionary<InFields, string>();

            this.Encoding = encoding;
            this.Environment = environment;
        }
 private static UrchinAnalyticsClient CreateSampleClient(Action<Uri> sender)
 {
     var configuration = new UrchinConfiguration("UA-1234-5", "FindHostName");
     var sessionManager = new SessionManager(TimeSpan.FromDays(1), null);
     var environment = new Environment("en-gb");
     return new UrchinAnalyticsClient(configuration, sessionManager, environment, sender);
 }
 private IEnumerable<Event> TestDiscreteTimeSteps(Environment env, List<DateTime> log)
 {
     while (true) {
     log.Add(env.Now);
     yield return env.Timeout(TimeSpan.FromSeconds(1));
       }
 }
 public Plant(int _x, int _y, Environment env)
     : base("bush", env)
 {
     x = _x;
     y = _y;
     init();
 }
Beispiel #20
0
        public override Statistics run()
        {
            Environment env = new Environment();

            //dist
            List<double> valueList = new List<double>() { 1, 2, 3, 4, 5 };
            List<double> distribution = new List<double>() { 0.5, 0.6, 0.7, 0.8, 1.0 };
            Discrete d = new Discrete(valueList, distribution);
            //dist1
            Uniform n = new Uniform(1, 3);
            Distribution dist = new Distribution(d);
            Distribution dist1 = new Distribution(n);

            Create c = new Create(env, 0, 20, dist);

            Dispose di = new Dispose(env, 1);

            Queue q = new Queue(env, 3);
            q.Capacity = 1;
            Resource r = new Resource(env, 2, 1, dist1, q);

            c.Next_AID.Add("First", 2);
            r.Next_AID.Add("First", 1);

            env.System_Time = new DateTime(1970, 1, 1, 0, 0, 0);
            env.Start_Time = new DateTime(1970, 1, 1, 0, 0, 0);
            env.Setup_Simulation();
            return env.Simulate();
        }
Beispiel #21
0
        public object ExpandList(IList<object> node, int backquoteDepth, Environment environment)
        {
            var result = new List<object>();

            foreach (var child in node)
            {
                var t = child.GetType();

                if (t == typeof(SpliceNode))
                {
                    var spliceList = evaluator.Evaluate(Expand(((SpliceNode)child).InnerValue, backquoteDepth - 1, environment), environment) as IList<object>;
                    if (spliceList == null)
                    {
                        throw new ArgumentException("Cannot splice non-list!");
                    }

                    result.AddRange(spliceList);
                }
                else if (t == typeof(List<object>) || t == typeof(UnquoteNode))
                {
                    result.Add(Expand(child, backquoteDepth, environment));
                }
                else
                {
                    result.Add(child);
                }
            }

            return result;
        }
 public void TestTriggeredTimeout()
 {
     var env = new Environment();
       env.Process(TestTriggeredTimeout(env));
       env.Run();
       Assert.AreEqual(2, env.NowD);
 }
 public Configuration()
 {
     EnvironmentSettings = new Environment();
     AgentSettings = new Agent();
     TagSettings = new Tag();
     ResourceSettings = new Resource();
 }
Beispiel #24
0
 static IEnumerable<Event> Benchmark2Source(Environment env)
 {
     while (true) {
     yield return env.Process(Benchmark2Sink(env));
     perf++;
       }
 }
			/// <summary>
			/// Initializes a new instance of the <see cref="Subrule"/> class.
			/// </summary>
			/// <param name="rhs">The RHS.</param>
			/// <param name="env">The environment.</param>
			/// <param name="rule">The phonological rule.</param>
			/// <exception cref="System.ArgumentException">Thrown when the size of the RHS is greater than the
			/// size of the specified rule's LHS and the LHS's size is greater than 1. A standard phonological
			/// rule does not currently support this type of widening.</exception>
			public Subrule(PhoneticPattern rhs, Environment env, StandardPhonologicalRule rule)
			{
				m_rhs = rhs;
				m_env = env;
				m_rule = rule;

				switch (Type)
				{
					case ChangeType.NARROW:
					case ChangeType.EPENTHESIS:
						// analysis target is a copy of the RHS, because there is no LHS
						m_analysisTarget = m_rhs.Clone();
						break;

					case ChangeType.WIDEN:
						// before generating the analysis we must extend the length of the LHS
						// to match the length of the RHS
						PhoneticPattern lhs = m_rule.m_lhs.Clone();
						while (lhs.Count != m_rhs.Count)
							lhs.Add(lhs.First.Clone());
						m_analysisTarget = m_rhs.Combine(lhs);
						break;

					case ChangeType.FEATURE:
						m_analysisTarget = m_rhs.Combine(m_rule.m_lhs);
						break;

					case ChangeType.UNKNOWN:
						throw new ArgumentException(HCStrings.kstidInvalidSubruleType, "rhs");
				}
			}
Beispiel #26
0
 public Schema(Environment env, IndexMap indexMap)
 {
     Id = env.NextPropertyMapId();
     Env = env;
     IndexMap = indexMap;
     SubSchemas = new SchemaMap();
 }
Beispiel #27
0
    /// <summary>
    /// Performs an update of the mod loader.
    /// </summary>
    public async Task Update()
    {
        if (ApplicationInstanceTracker.GetAllProcesses(out var processes))
        {
            ActionWrappers.ExecuteWithApplicationDispatcher(() =>
            {
                // Accumulate list of processes.
                string allProcessString = $"\n{Resources.UpdateLoaderProcessList.Get()}:";
                foreach (var process in processes)
                {
                    allProcessString += $"\n({process.Id}) {process.ProcessName}";
                }

                Actions.DisplayMessagebox.Invoke(Resources.UpdateLoaderRunningTitle.Get(), Resources.UpdateLoaderRunningMessage.Get() + allProcessString, new Actions.DisplayMessageBoxParams()
                {
                    StartupLocation = Actions.WindowStartupLocation.CenterScreen
                });
            });
        }
        else
        {
            _manager.OnApplySelfUpdate += OnApplySelfUpdate;
            await _manager.PrepareUpdateAsync(_targetVersion, new Progress <double>(d => { Progress = d * 100; }));

            await _manager.StartUpdateAsync(_targetVersion, new OutOfProcessOptions()
            {
                Restart = true
            }, new UpdateOptions()
            {
                CleanupAfterUpdate = true
            });

            Environment.Exit(0);
        }
    }
Beispiel #28
0
        public OfWord(Environment env)
            : base("of", env)
        {
            OfBodyWord = new ControlFlowWord("of-body", env);

            PrimitiveExecuteAction = executeOf;
        }
Beispiel #29
0
 static IEnumerable<Event> Benchmark1Proc(Environment env, int n)
 {
     while (true) {
     yield return env.TimeoutUniform(TimeSpan.Zero, TimeSpan.FromSeconds(2 * n));
     perf++;
       }
 }
Beispiel #30
0
 void getPath()
 {
     audioFolderPath  = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments).Replace("\\", "/");
     audioFolderPath += "/My Games/Containment Breach VR/Custom Radio Tracks/";
     System.IO.Directory.CreateDirectory(audioFolderPath);
     Debug.Log(audioFolderPath);
 }
Beispiel #31
0
        public void OnRequest(HttpRequestHead head, IDataProducer body, IHttpResponseDelegate response)
        {
            var env = new Environment();

            if (context != null)
                foreach (var kv in context)
                    env[kv.Key] = kv.Value;

            env.Headers = head.Headers ?? new Dictionary<string, string>();
            env.Method = head.Method ?? "";
            env.Path = head.Path ?? "";
            env.PathBase = "";
            env.QueryString = head.QueryString ?? "";
            env.Scheme = "http"; // XXX
            env.Version = "1.0";

            if (body == null)
                env.Body = null;
            else
                env.Body = (onData, onError, onEnd) =>
                {
                    var d = body.Connect(new DataConsumer(onData, onError, onEnd));
                    return () => { if (d != null) d.Dispose(); };
                };

            appDelegate(env, HandleResponse(response), HandleError(response));
        }
 public void TestInitialiContainerCapacity()
 {
     var env = new Environment();
       var container = new Container(env);
       Assert.AreEqual(0, container.Level);
       Assert.AreEqual(double.MaxValue, container.Capacity);
 }
    /// <summary>
    /// Intercepts logs from the console and provides the ability to flush them to a file in the event of a crash.
    /// </summary>
    /// <param name="logger">The logger to intercept logs from.</param>
    /// <param name="outputDir">The directory to which the log is output to.</param>
    public LogWriter(Logger logger, string outputDir)
    {
        var executableName    = Path.GetFileNameWithoutExtension(Environment.GetCommandLineArgs()[0]);
        var universalDateTime = DateTime.UtcNow.ToString("yyyy-MM-dd HH.mm.ss");

        Directory.CreateDirectory(outputDir);

        _logItems = new List <string>(MaxBufferLength + 1);
        _logger   = logger;
        _logger.OnPrintMessage += OnPrintMessage;

        // Add integer to file path in case there is another instance of same process launched at the same time.
        string GetLogFilePath()
        {
            for (int x = 0; x < short.MaxValue; x++)
            {
                var filePath = x == 0 ?
                               Path.Combine(outputDir, $"{universalDateTime} ~ {executableName}.txt") :
                               Path.Combine(outputDir, $"{universalDateTime} ~ {executableName} [{x}].txt");

                if (!File.Exists(filePath))
                {
                    return(filePath);
                }
            }

            return(default);
Beispiel #34
0
 private static void PopulateCommandLineArgs()
 {
     string[] args = Environment.GetCommandLineArgs();
     for (int index = 1; index < args.Length; index += 2)
     {
         _commandLineArguments.Add(args[index], args[index + 1]);
     }
 }
Beispiel #35
0
    /// <summary>
    /// Sets the Reloaded Mod Loader DLL paths for a launcher config.
    /// </summary>
    private static void SetLoaderPaths(LoaderConfig config, string launcherDirectory)
    {
        if (String.IsNullOrEmpty(launcherDirectory))
        {
            throw new DllNotFoundException("The provided launcher directory is null or empty. This is a bug. Report this to the developer.");
        }

        config.UpdatePaths(launcherDirectory, Resources.ErrorLoaderNotFound.Get());

        // Update Environment Variables
        Task.Run(() => Environment.SetEnvironmentVariable("RELOADEDIIMODS", config.GetModConfigDirectory(), EnvironmentVariableTarget.User));
    }
Beispiel #36
0
    public static string getGameDataPath()
    {
        string gameDataPath;

        #if UNITY_STANDALONE_WIN
        gameDataPath =
            Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments).Replace("\\", "/");
        gameDataPath += "/My Games/Mindys/Saves";
        #else
        savedGamesPath = Application.persistentDataPath + "/";
        #endif
        return(gameDataPath);
    }
    /// <inheritdoc />
    public void Execute(object?parameter)
    {
        var loaderConfig = IoC.Get <LoaderConfig>();
        var shell        = (IShellLink) new ShellLink();

        var appLocation = ApplicationConfig.GetAbsoluteAppLocation(_config);

        shell.SetDescription($"Launch {_config?.Config.AppName} via Reloaded II");
        shell.SetPath($"\"{loaderConfig.LauncherPath}\"");
        shell.SetArguments($"{Constants.ParameterLaunch} \"{appLocation}\"");
        shell.SetWorkingDirectory(Path.GetDirectoryName(loaderConfig.LauncherPath) !);

        if (_config != null)
        {
            var hasIcon = _config.Config.TryGetApplicationIcon(_config.Path, out var logoPath);
            if (hasIcon)
            {
                // Make path for icon.
                string newPath = Path.ChangeExtension(logoPath, ".ico");

                // Convert to ICO.
                _iconConverter.TryConvertToIcon(logoPath, newPath);
                shell.SetIconLocation(newPath, 0);
            }
            else
            {
                shell.SetIconLocation(appLocation, 0);
            }
        }

        // Save the shortcut.
        var file = (IPersistFile)shell;
        var link = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory), $"{_config?.Config.AppName} (Reloaded).lnk");

        file.Save(link, false);

        Actions.DisplayMessagebox?.Invoke(Resources.AddAppShortcutCreatedTitle.Get(),
                                          $"{Resources.AddAppShortcutCreatedMessage.Get()} {link}",
                                          new Actions.DisplayMessageBoxParams()
        {
            StartupLocation = Actions.WindowStartupLocation.CenterScreen
        });
    }
Beispiel #38
0
        private static string ResolveRelativePathToProgramFiles(string relativeX86Path, string relativeX64Path, string errorMessge)
        {
            string programFiles = SystemEnvironment.GetFolderPath(SystemEnvironment.SpecialFolder.ProgramFilesX86);
            string path         = Path.Combine(programFiles, relativeX86Path);

            if (!File.Exists(path))
            {
                programFiles = SystemEnvironment.GetEnvironmentVariable(ProgramFiles64bitKey) ?? SystemEnvironment.GetFolderPath(SystemEnvironment.SpecialFolder.ProgramFiles);
                path         = Path.Combine(programFiles, relativeX64Path);
            }

            if (!File.Exists(path))
            {
                throw new InvalidOperationException(errorMessge);
            }

            return(path);
        }
Beispiel #39
0
 /// <summary/>
 public static string GetEnvironmentVariable(string variable)
 {
     return(TrustedEnvironment.GetEnvironmentVariable(variable));
 }
Beispiel #40
0
        private PowerShellExecutionResults run_host(ChocolateyConfiguration config, string chocoPowerShellScript)
        {
            // since we control output in the host, always set these true
            Environment.SetEnvironmentVariable("ChocolateyEnvironmentDebug", "true");
            Environment.SetEnvironmentVariable("ChocolateyEnvironmentVerbose", "true");

            var    result       = new PowerShellExecutionResults();
            string commandToRun = wrap_script_with_module(chocoPowerShellScript, config);
            var    host         = new PoshHost(config);

            this.Log().Debug(() => "Calling built-in PowerShell host with ['{0}']".format_with(commandToRun.escape_curly_braces()));

            var initialSessionState = InitialSessionState.CreateDefault();

            // override system execution policy without accidentally setting it
            initialSessionState.AuthorizationManager = new AuthorizationManager("choco");
            using (var runspace = RunspaceFactory.CreateRunspace(host, initialSessionState))
            {
                runspace.Open();

                // this will affect actual execution policy
                //RunspaceInvoke invoker = new RunspaceInvoke(runspace);
                //invoker.Invoke("Set-ExecutionPolicy ByPass");

                using (var pipeline = runspace.CreatePipeline())
                {
                    // The powershell host itself handles the following items:
                    // * Write-Debug
                    // * Write-Host
                    // * Write-Verbose
                    // * Write-Warning
                    //
                    // the two methods below will pick up Write-Output and Write-Error

                    // Write-Output
                    pipeline.Output.DataReady += (sender, args) =>
                    {
                        PipelineReader <PSObject> reader = sender as PipelineReader <PSObject>;

                        if (reader != null)
                        {
                            while (reader.Count > 0)
                            {
                                host.UI.WriteLine(reader.Read().to_string().escape_curly_braces());
                            }
                        }
                    };

                    // Write-Error
                    pipeline.Error.DataReady += (sender, args) =>
                    {
                        PipelineReader <object> reader = sender as PipelineReader <object>;

                        if (reader != null)
                        {
                            while (reader.Count > 0)
                            {
                                host.UI.WriteErrorLine(reader.Read().to_string().escape_curly_braces());
                            }
                        }
                    };

                    var documentsFolder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments, Environment.SpecialFolderOption.DoNotVerify);
                    var currentUserCurrentHostProfile = _fileSystem.combine_paths(documentsFolder, "WindowsPowerShell\\Microsoft.PowerShell_profile.ps1");
                    var recreateProfileScript         = @"
if ((Test-Path(""{0}"")) -and ($profile -eq $null -or $profile -eq '')) {{
  $global:profile = ""{1}""
}}
".format_with(documentsFolder, currentUserCurrentHostProfile);

                    pipeline.Commands.Add(new Command(recreateProfileScript, isScript: true, useLocalScope: false));

                    // The PowerShell Output Redirection bug affects System.Management.Automation
                    // it appears with v3 more than others. It is already known to affect v2
                    // this implements the redirection fix from the post below, fixed up with some comments
                    // http://www.leeholmes.com/blog/2008/07/30/workaround-the-os-handles-position-is-not-what-filestream-expected/
                    const string outputRedirectionFixScript = @"
try {
  $bindingFlags = [Reflection.BindingFlags] ""Instance,NonPublic,GetField""
  $objectRef = $host.GetType().GetField(""externalHostRef"", $bindingFlags).GetValue($host)
  $bindingFlags = [Reflection.BindingFlags] ""Instance,NonPublic,GetProperty""
  $consoleHost = $objectRef.GetType().GetProperty(""Value"", $bindingFlags).GetValue($objectRef, @())
  [void] $consoleHost.GetType().GetProperty(""IsStandardOutputRedirected"", $bindingFlags).GetValue($consoleHost, @())
  $bindingFlags = [Reflection.BindingFlags] ""Instance,NonPublic,GetField""
  $field = $consoleHost.GetType().GetField(""standardOutputWriter"", $bindingFlags)
  $field.SetValue($consoleHost, [Console]::Out)
  [void] $consoleHost.GetType().GetProperty(""IsStandardErrorRedirected"", $bindingFlags).GetValue($consoleHost, @())
  $field2 = $consoleHost.GetType().GetField(""standardErrorWriter"", $bindingFlags)
  $field2.SetValue($consoleHost, [Console]::Error)
} catch {
  Write-Output ""Unable to apply redirection fix""
}
";
                    pipeline.Commands.Add(new Command(outputRedirectionFixScript, isScript: true, useLocalScope: false));
                    pipeline.Commands.Add(new Command(commandToRun, isScript: true, useLocalScope: false));

                    try
                    {
                        pipeline.Invoke();
                    }
                    catch (RuntimeException ex)
                    {
                        var errorStackTrace = ex.StackTrace;
                        var record          = ex.ErrorRecord;
                        if (record != null)
                        {
                            // not available in v1
                            //errorStackTrace = record.ScriptStackTrace;
                            var scriptStackTrace = record.GetType().GetProperty("ScriptStackTrace");
                            if (scriptStackTrace != null)
                            {
                                var scriptError = scriptStackTrace.GetValue(record, null).to_string();
                                if (!string.IsNullOrWhiteSpace(scriptError))
                                {
                                    errorStackTrace = scriptError;
                                }
                            }
                        }
                        this.Log().Error("ERROR: {0}{1}".format_with(ex.Message.escape_curly_braces(), !config.Debug ? string.Empty : "{0} {1}".format_with(Environment.NewLine, errorStackTrace.escape_curly_braces())));
                    }
                    catch (Exception ex)
                    {
                        // Unfortunately this doesn't print line number and character. It might be nice to get back to those items unless it involves tons of work.
                        this.Log().Error("ERROR: {0}{1}".format_with(ex.Message.escape_curly_braces(), !config.Debug ? string.Empty : "{0} {1}".format_with(Environment.NewLine, ex.StackTrace.escape_curly_braces())));
                    }

                    if (pipeline.PipelineStateInfo != null)
                    {
                        switch (pipeline.PipelineStateInfo.State)
                        {
                        // disconnected is not available unless the assembly version is at least v3
                        //case PipelineState.Disconnected:
                        case PipelineState.Running:
                        case PipelineState.NotStarted:
                        case PipelineState.Failed:
                        case PipelineState.Stopping:
                        case PipelineState.Stopped:
                            if (host.ExitCode == 0)
                            {
                                host.SetShouldExit(1);
                            }
                            host.HostException = pipeline.PipelineStateInfo.Reason;
                            break;

                        case PipelineState.Completed:
                            if (host.ExitCode == -1)
                            {
                                host.SetShouldExit(0);
                            }
                            break;
                        }
                    }
                }
            }

            this.Log().Debug("Built-in PowerShell host called with ['{0}'] exited with '{1}'.".format_with(commandToRun.escape_curly_braces(), host.ExitCode));

            result.ExitCode             = host.ExitCode;
            result.StandardErrorWritten = host.StandardErrorWritten;

            return(result);
        }
Beispiel #41
0
        internal static string ResolveFSharpCPath()
        {
            string programFiles = SystemEnvironment.GetFolderPath(SystemEnvironment.SpecialFolder.ProgramFilesX86);

            return(Path.Combine(programFiles, @"Microsoft SDKs", "F#", "3.1", "Framework", "v4.0", "Fsc.exe"));
        }
Beispiel #42
0
        public string GetLocalFilePath(string filename)
        {
            string path = Environment.GetFolderPath(Environment.SpecialFolder.Personal);

            return(Path.Combine(path, filename));
        }
Beispiel #43
0
        public bool run_action(ChocolateyConfiguration configuration, PackageResult packageResult, CommandNameType command)
        {
            var installerRun = false;

            var packageDirectory = packageResult.InstallLocation;

            if (packageDirectory.is_equal_to(ApplicationParameters.InstallLocation) || packageDirectory.is_equal_to(ApplicationParameters.PackagesLocation))
            {
                packageResult.Messages.Add(
                    new ResultMessage(
                        ResultType.Error,
                        "Install location is not specific enough, cannot run PowerShell script:{0} Erroneous install location captured as '{1}'".format_with(Environment.NewLine, packageResult.InstallLocation)
                        )
                    );

                return(false);
            }

            if (!_fileSystem.directory_exists(packageDirectory))
            {
                packageResult.Messages.Add(new ResultMessage(ResultType.Error, "Package install not found:'{0}'".format_with(packageDirectory)));
                return(installerRun);
            }

            var chocoPowerShellScript = get_script_for_action(packageResult, command);

            if (!string.IsNullOrEmpty(chocoPowerShellScript))
            {
                var failure = false;

                ConfigurationBuilder.set_environment_variables(configuration);

                var package = packageResult.Package;
                Environment.SetEnvironmentVariable("chocolateyPackageName", package.Id);
                Environment.SetEnvironmentVariable("packageName", package.Id);
                Environment.SetEnvironmentVariable("chocolateyPackageVersion", package.Version.to_string());
                Environment.SetEnvironmentVariable("packageVersion", package.Version.to_string());
                Environment.SetEnvironmentVariable("chocolateyPackageFolder", packageDirectory);
                Environment.SetEnvironmentVariable("packageFolder", packageDirectory);


                // unset variables that may not be updated so they don't get passed again
                Environment.SetEnvironmentVariable("installArguments", null);
                Environment.SetEnvironmentVariable("installerArguments", null);
                Environment.SetEnvironmentVariable("chocolateyInstallArguments", null);
                Environment.SetEnvironmentVariable("packageParameters", null);
                Environment.SetEnvironmentVariable("chocolateyPackageParameters", null);
                Environment.SetEnvironmentVariable("chocolateyInstallOverride", null);

                // we only want to pass the following args to packages that would apply.
                // like choco install git -params '' should pass those params to git.install,
                // but not another package
                if (!package_is_a_dependency_not_a_virtual(configuration, package.Id))
                {
                    this.Log().Debug(ChocolateyLoggers.Verbose, "Setting installer args and package parameters for {0}".format_with(package.Id));
                    Environment.SetEnvironmentVariable("installArguments", configuration.InstallArguments);
                    Environment.SetEnvironmentVariable("installerArguments", configuration.InstallArguments);
                    Environment.SetEnvironmentVariable("chocolateyInstallArguments", configuration.InstallArguments);
                    Environment.SetEnvironmentVariable("packageParameters", configuration.PackageParameters);
                    Environment.SetEnvironmentVariable("chocolateyPackageParameters", configuration.PackageParameters);

                    if (configuration.OverrideArguments)
                    {
                        Environment.SetEnvironmentVariable("chocolateyInstallOverride", "true");
                    }
                }

                if (configuration.ForceX86)
                {
                    Environment.SetEnvironmentVariable("chocolateyForceX86", "true");
                }

                if (configuration.NotSilent)
                {
                    Environment.SetEnvironmentVariable("chocolateyInstallOverride", "true");
                }

                //todo:if (configuration.NoOutput)
                //{
                //    Environment.SetEnvironmentVariable("ChocolateyEnvironmentQuiet","true");
                //}

                if (package.IsDownloadCacheAvailable)
                {
                    foreach (var downloadCache in package.DownloadCache.or_empty_list_if_null())
                    {
                        var urlKey = CryptoHashProvider.hash_value(downloadCache.OriginalUrl, CryptoHashProviderType.Sha256).Replace("=", string.Empty);
                        Environment.SetEnvironmentVariable("CacheFile_{0}".format_with(urlKey), downloadCache.FileName);
                        Environment.SetEnvironmentVariable("CacheChecksum_{0}".format_with(urlKey), downloadCache.Checksum);
                        Environment.SetEnvironmentVariable("CacheChecksumType_{0}".format_with(urlKey), "sha512");
                    }
                }

                this.Log().Debug(ChocolateyLoggers.Important, "Contents of '{0}':".format_with(chocoPowerShellScript));
                string chocoPowerShellScriptContents = _fileSystem.read_file(chocoPowerShellScript);
                this.Log().Debug(chocoPowerShellScriptContents.escape_curly_braces());

                bool shouldRun = !configuration.PromptForConfirmation;

                if (!shouldRun)
                {
                    this.Log().Info(ChocolateyLoggers.Important, () => "The package {0} wants to run '{1}'.".format_with(package.Id, _fileSystem.get_file_name(chocoPowerShellScript)));
                    this.Log().Info(ChocolateyLoggers.Important, () => "Note: If you don't run this script, the installation will fail.");
                    this.Log().Info(ChocolateyLoggers.Important, () => @"Note: To confirm automatically next time, use '-y' or consider setting 
 'allowGlobalConfirmation'. Run 'choco feature -h' for more details.");

                    var selection = InteractivePrompt.prompt_for_confirmation(@"Do you want to run the script?",
                                                                              new[] { "yes", "no", "print" },
                                                                              defaultChoice: null,
                                                                              requireAnswer: true,
                                                                              allowShortAnswer: true,
                                                                              shortPrompt: true
                                                                              );

                    if (selection.is_equal_to("print"))
                    {
                        this.Log().Info(ChocolateyLoggers.Important, "------ BEGIN SCRIPT ------");
                        this.Log().Info(() => "{0}{1}{0}".format_with(Environment.NewLine, chocoPowerShellScriptContents.escape_curly_braces()));
                        this.Log().Info(ChocolateyLoggers.Important, "------- END SCRIPT -------");
                        selection = InteractivePrompt.prompt_for_confirmation(@"Do you want to run this script?",
                                                                              new[] { "yes", "no" },
                                                                              defaultChoice: null,
                                                                              requireAnswer: true,
                                                                              allowShortAnswer: true,
                                                                              shortPrompt: true
                                                                              );
                    }

                    if (selection.is_equal_to("yes"))
                    {
                        shouldRun = true;
                    }
                    if (selection.is_equal_to("no"))
                    {
                        Environment.ExitCode = 1;
                        packageResult.Messages.Add(new ResultMessage(ResultType.Error, "User cancelled powershell portion of installation for '{0}'.{1} Specify -n to skip automated script actions.".format_with(chocoPowerShellScript, Environment.NewLine)));
                    }
                }

                if (shouldRun)
                {
                    installerRun = true;

                    if (configuration.Features.UsePowerShellHost)
                    {
                        add_assembly_resolver();
                    }

                    var result = new PowerShellExecutionResults
                    {
                        ExitCode = -1
                    };

                    try
                    {
                        result = configuration.Features.UsePowerShellHost
                                    ? Execute.with_timeout(configuration.CommandExecutionTimeoutSeconds).command(() => run_host(configuration, chocoPowerShellScript), result)
                                    : run_external_powershell(configuration, chocoPowerShellScript);
                    }
                    catch (Exception ex)
                    {
                        this.Log().Error(ex.Message.escape_curly_braces());
                        result.ExitCode = -1;
                    }

                    if (configuration.Features.UsePowerShellHost)
                    {
                        remove_assembly_resolver();
                    }

                    if (result.StandardErrorWritten && configuration.Features.FailOnStandardError)
                    {
                        failure = true;
                    }
                    else if (result.StandardErrorWritten && result.ExitCode == 0)
                    {
                        this.Log().Warn(
                            () =>
                            @"Only an exit code of non-zero will fail the package by default. Set 
 `--failonstderr` if you want error messages to also fail a script. See 
 `choco -h` for details.");
                    }


                    if (result.ExitCode != 0)
                    {
                        Environment.ExitCode   = result.ExitCode;
                        packageResult.ExitCode = result.ExitCode;
                    }

                    // 0 - most widely used success exit code
                    // MSI valid exit codes
                    // 1605 - (uninstall) - the product is not found, could have already been uninstalled
                    // 1614 (uninstall) - the product is uninstalled
                    // 1641 - restart initiated
                    // 3010 - restart required
                    var validExitCodes = new List <int> {
                        0, 1605, 1614, 1641, 3010
                    };
                    if (!validExitCodes.Contains(result.ExitCode))
                    {
                        failure = true;
                    }

                    if (failure)
                    {
                        packageResult.Messages.Add(new ResultMessage(ResultType.Error, "Error while running '{0}'.{1} See log for details.".format_with(chocoPowerShellScript, Environment.NewLine)));
                    }
                    packageResult.Messages.Add(new ResultMessage(ResultType.Note, "Ran '{0}'".format_with(chocoPowerShellScript)));
                }
            }

            return(installerRun);
        }
Beispiel #44
0
        // ReSharper disable InconsistentNaming
        private static void Main(string[] args)
        // ReSharper restore InconsistentNaming
        {
            try
            {
                add_assembly_resolver();

                string loggingLocation = ApplicationParameters.LoggingLocation;
                //no file system at this point
                if (!Directory.Exists(loggingLocation))
                {
                    Directory.CreateDirectory(loggingLocation);
                }

                Log4NetAppenderConfiguration.configure(loggingLocation, excludeLoggerNames: ChocolateyLoggers.Trace.to_string());
                Bootstrap.initialize();
                Bootstrap.startup();
                var license   = License.validate_license();
                var container = SimpleInjectorContainer.Container;

                "LogFileOnly".Log().Info(() => "".PadRight(60, '='));

                var config     = Config.get_configuration_settings();
                var fileSystem = container.GetInstance <IFileSystem>();

                var warnings = new List <string>();

                ConfigurationBuilder.set_up_configuration(
                    args,
                    config,
                    container,
                    license,
                    warning => { warnings.Add(warning); }
                    );

                if (config.Features.LogWithoutColor)
                {
                    ApplicationParameters.Log4NetConfigurationResource = @"chocolatey.infrastructure.logging.log4net.nocolor.config.xml";
                    Log4NetAppenderConfiguration.configure(loggingLocation, excludeLoggerNames: ChocolateyLoggers.Trace.to_string());
                }

                if (!string.IsNullOrWhiteSpace(config.AdditionalLogFileLocation))
                {
                    Log4NetAppenderConfiguration.configure_additional_log_file(fileSystem.get_full_path(config.AdditionalLogFileLocation));
                }

                report_version_and_exit_if_requested(args, config);

                trap_exit_scenarios(config);

                warn_on_nuspec_or_nupkg_usage(args, config);

                if (config.RegularOutput)
                {
#if DEBUG
                    "chocolatey".Log().Info(ChocolateyLoggers.Important, () => "{0} v{1}{2} (DEBUG BUILD)".format_with(ApplicationParameters.Name, config.Information.ChocolateyProductVersion, license.is_licensed_version() ? " {0}".format_with(license.LicenseType) : string.Empty));
#else
                    "chocolatey".Log().Info(ChocolateyLoggers.Important, () => "{0} v{1}{2}".format_with(ApplicationParameters.Name, config.Information.ChocolateyProductVersion, license.is_licensed_version() ? " {0}".format_with(license.LicenseType) : string.Empty));
#endif
                    if (args.Length == 0)
                    {
                        "chocolatey".Log().Info(ChocolateyLoggers.Important, () => "Please run 'choco -?' or 'choco <command> -?' for help menu.");
                    }
                }

                if (warnings.Count != 0 && config.RegularOutput)
                {
                    foreach (var warning in warnings.or_empty_list_if_null())
                    {
                        "chocolatey".Log().Warn(ChocolateyLoggers.Important, warning);
                    }
                }

                if (config.HelpRequested || config.UnsuccessfulParsing)
                {
                    pause_execution_if_debug();
                    Environment.Exit(config.UnsuccessfulParsing ? 1 : 0);
                }

                var verboseAppenderName = "{0}LoggingColoredConsoleAppender".format_with(ChocolateyLoggers.Verbose.to_string());
                var traceAppenderName   = "{0}LoggingColoredConsoleAppender".format_with(ChocolateyLoggers.Trace.to_string());
                Log4NetAppenderConfiguration.set_logging_level_debug_when_debug(config.Debug, verboseAppenderName, traceAppenderName);
                Log4NetAppenderConfiguration.set_verbose_logger_when_verbose(config.Verbose, config.Debug, verboseAppenderName);
                Log4NetAppenderConfiguration.set_trace_logger_when_trace(config.Trace, traceAppenderName);
                "chocolatey".Log().Debug(() => "{0} is running on {1} v {2}".format_with(ApplicationParameters.Name, config.Information.PlatformType, config.Information.PlatformVersion.to_string()));
                //"chocolatey".Log().Debug(() => "Command Line: {0}".format_with(Environment.CommandLine));

                remove_old_chocolatey_exe(fileSystem);

                AssemblyFileExtractor.extract_all_resources_to_relative_directory(fileSystem, Assembly.GetAssembly(typeof(Program)), ApplicationParameters.InstallLocation, new List <string>(), "chocolatey.console", throwError: false);
                //refactor - thank goodness this is temporary, cuz manifest resource streams are dumb
                IList <string> folders = new List <string>
                {
                    "helpers",
                    "functions",
                    "redirects",
                    "tools"
                };
#if !NoResources
                AssemblyFileExtractor.extract_all_resources_to_relative_directory(fileSystem, Assembly.GetAssembly(typeof(ChocolateyResourcesAssembly)), ApplicationParameters.InstallLocation, folders, ApplicationParameters.ChocolateyFileResources, throwError: false);
#endif
                var application = new ConsoleApplication();
                application.run(args, config, container);
            }
            catch (Exception ex)
            {
                if (ApplicationParameters.is_debug_mode_cli_primitive())
                {
                    "chocolatey".Log().Error(() => "{0} had an error occur:{1}{2}".format_with(
                                                 ApplicationParameters.Name,
                                                 Environment.NewLine,
                                                 ex.ToString()));
                }
                else
                {
                    "chocolatey".Log().Error(ChocolateyLoggers.Important, () => "{0}".format_with(ex.Message));
                    "chocolatey".Log().Error(ChocolateyLoggers.LogFileOnly, () => "More Details: {0}".format_with(ex.ToString()));
                }

                if (Environment.ExitCode == 0)
                {
                    Environment.ExitCode = 1;
                }
            }
            finally
            {
                "chocolatey".Log().Debug(() => "Exiting with {0}".format_with(Environment.ExitCode));
#if DEBUG
                "chocolatey".Log().Info(() => "Exiting with {0}".format_with(Environment.ExitCode));
#endif
                pause_execution_if_debug();
                Bootstrap.shutdown();
                Environment.Exit(Environment.ExitCode);
            }
        }
Beispiel #45
0
        internal override string ResolveMSBuild15Dir()
        {
            string programFiles = SystemEnvironment.GetFolderPath(SystemEnvironment.SpecialFolder.ProgramFilesX86);

            return(Path.Combine(programFiles, "MSBuild-15.3.409.57025", "MSBuild", "15.0", "Bin"));
        }
Beispiel #46
0
        internal override string ResolveNpmGlobalPrefix()
        {
            string appDataDirectory = SystemEnvironment.GetFolderPath(SystemEnvironment.SpecialFolder.ApplicationData);

            return(Path.Combine(appDataDirectory, "npm"));
        }
Beispiel #47
0
        internal override string ResolveVsTestPath()
        {
            string programFiles = SystemEnvironment.GetFolderPath(SystemEnvironment.SpecialFolder.ProgramFilesX86);

            return(Path.Combine(programFiles, "Microsoft Visual Studio 11.0", "Common7", "IDE", "CommonExtensions", "Microsoft", "TestWindow", "vstest.console.exe"));
        }
Beispiel #48
0
        internal override string ResolveSQLCmdPath()
        {
            string programFiles = SystemEnvironment.GetFolderPath(SystemEnvironment.SpecialFolder.ProgramFilesX86);

            return(Path.Combine(programFiles, "Microsoft SQL Server", "110", "Tools", "Binn", "sqlcmd.exe"));
        }
Beispiel #49
0
 /// <summary/>
 public static string ExpandEnvironmentVariables(String name)
 {
     return(TrustedEnvironment.ExpandEnvironmentVariables(name));
 }
Beispiel #50
0
        internal override string ResolveMSBuildPath()
        {
            string programFiles = SystemEnvironment.GetFolderPath(SystemEnvironment.SpecialFolder.ProgramFilesX86);

            return(Path.Combine(programFiles, "MSBuild", "14.0", "Bin", "MSBuild.exe"));
        }
Beispiel #51
0
 public static bool IsCI()
 {
     return(!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("BUILD_NUMBER")));
 }
Beispiel #52
0
        static void Main(string[] args)
        {
            var options = new Options();
            var modifed = new List <string>();

            if (args != null)
            {
                if (args.Length == 1 && !args[0].StartsWith("-"))
                {
                    modifed.Add("-f");
                    modifed.Add(args[0]);
                }
                else
                {
                    modifed.AddRange(args);
                }
            }

            if (!CommandLine.Parser.Default.ParseArguments(modifed.ToArray(), options))
            {
                Environment.ExitCode = Error;
                return;
            }

            var request = new Request(options.File)
            {
                Configuration = options.Configuration ?? "default.xml",
                Types         = options.Types,
                View          = options.Table,
                Provider      = options.Provider,
                Server        = options.Server,
                Database      = options.Database,
                Schema        = options.Schema,
                User          = options.User,
                Password      = options.Password,
                Port          = options.Port
            };

            if (!request.IsValid())
            {
                Console.Error.WriteLine(request.Message);
                Environment.Exit(Error);
            }

            try {
                using (var bootstrapper = new Bootstrapper(request)) {
                    var cfg = bootstrapper.Resolve <Cfg>();

                    if (cfg.Errors().Any())
                    {
                        foreach (var error in cfg.Errors())
                        {
                            Console.Error.WriteLine(error);
                            Environment.ExitCode = Error;
                        }
                    }
                    else
                    {
                        var response = bootstrapper.Resolve <Importer>().Import();
                        if (response.Records != 0)
                        {
                            return;
                        }
                        Console.Error.WriteLine("Did not import any records!");
                        Environment.ExitCode = Error;
                    }
                }
            } catch (Exception ex) {
                Console.Error.WriteLine(ex.Message);
                Environment.ExitCode = Error;
            }

            Environment.ExitCode = 0;
        }
Beispiel #53
0
 public static void Exit(int exitCode)
 {
     BeforeClose();
     Environment.Exit(exitCode);
 }
Beispiel #54
0
// ReSharper disable InconsistentNaming
        private static void Main(string[] args)
// ReSharper restore InconsistentNaming
        {
            try
            {
                string loggingLocation = ApplicationParameters.LoggingLocation;
                //no file system at this point
                if (!Directory.Exists(loggingLocation))
                {
                    Directory.CreateDirectory(loggingLocation);
                }

                Log4NetAppenderConfiguration.configure(loggingLocation);
                Bootstrap.initialize();
                Bootstrap.startup();

                var container  = SimpleInjectorContainer.Container;
                var config     = container.GetInstance <ChocolateyConfiguration>();
                var fileSystem = container.GetInstance <IFileSystem>();

                var warnings = new List <string>();

                ConfigurationBuilder.set_up_configuration(
                    args,
                    config,
                    fileSystem,
                    container.GetInstance <IXmlService>(),
                    warning => { warnings.Add(warning); }
                    );
                Config.initialize_with(config);

                report_version_and_exit_if_requested(args, config);

                trap_exit_scenarios(config);

                if (config.RegularOuptut)
                {
                    "logfile".Log().Info(() => "".PadRight(60, '='));
#if DEBUG
                    "chocolatey".Log().Info(ChocolateyLoggers.Important, () => "{0} v{1} (DEBUG BUILD)".format_with(ApplicationParameters.Name, config.Information.ChocolateyProductVersion));
#else
                    "chocolatey".Log().Info(ChocolateyLoggers.Important, () => "{0} v{1}".format_with(ApplicationParameters.Name, config.Information.ChocolateyProductVersion));
#endif
                }


                if (warnings.Count != 0 && config.RegularOuptut)
                {
                    foreach (var warning in warnings.or_empty_list_if_null())
                    {
                        "chocolatey".Log().Warn(ChocolateyLoggers.Important, warning);
                    }
                }

                if (config.HelpRequested)
                {
                    pause_execution_if_debug();
                    Environment.Exit(-1);
                }

                Log4NetAppenderConfiguration.set_verbose_logger_when_verbose(config.Verbose, ChocolateyLoggers.Verbose.to_string());
                Log4NetAppenderConfiguration.set_logging_level_debug_when_debug(config.Debug);
                "chocolatey".Log().Debug(() => "{0} is running on {1} v {2}".format_with(ApplicationParameters.Name, config.Information.PlatformType, config.Information.PlatformVersion.to_string()));
                //"chocolatey".Log().Debug(() => "Command Line: {0}".format_with(Environment.CommandLine));

                warn_when_admin_needs_elevation(config);
                remove_old_chocolatey_exe(fileSystem);

                LicenseValidation.validate(fileSystem);

                //refactor - thank goodness this is temporary, cuz manifest resource streams are dumb
                IList <string> folders = new List <string>
                {
                    "helpers",
                    "functions",
                    "redirects",
                    "tools"
                };
                AssemblyFileExtractor.extract_all_resources_to_relative_directory(fileSystem, Assembly.GetAssembly(typeof(ChocolateyResourcesAssembly)), ApplicationParameters.InstallLocation, folders, ApplicationParameters.ChocolateyFileResources);

                var application = new ConsoleApplication();
                application.run(args, config, container);
            }
            catch (Exception ex)
            {
                var debug = false;
                // no access to the good stuff here, need to go a bit primitive in parsing args
                foreach (var arg in args.or_empty_list_if_null())
                {
                    if (arg.Contains("debug") || arg.is_equal_to("-d") || arg.is_equal_to("/d"))
                    {
                        debug = true;
                        break;
                    }
                }

                if (debug)
                {
                    "chocolatey".Log().Error(() => "{0} had an error occur:{1}{2}".format_with(
                                                 ApplicationParameters.Name,
                                                 Environment.NewLine,
                                                 ex.ToString()));
                }
                else
                {
                    "chocolatey".Log().Error(ChocolateyLoggers.Important, () => "{0}".format_with(ex.Message));
                }

                Environment.ExitCode = 1;
            }
            finally
            {
                "chocolatey".Log().Debug(() => "Exiting with {0}".format_with(Environment.ExitCode));
#if DEBUG
                "chocolatey".Log().Info(() => "Exiting with {0}".format_with(Environment.ExitCode));
#endif
                pause_execution_if_debug();
                Bootstrap.shutdown();

                Environment.Exit(Environment.ExitCode);
            }
        }
Beispiel #55
0
        static void StartUp()
        {
            RunningOnCI    = !string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable("CI_SERVER"));
            RunningOnLinux = RuntimeInformation.IsOSPlatform(OSPlatform.Linux);

            if (RunningOnLinux)
            {
                ConsoleWrapper.WriteLine("Linux Environment detected!");
            }

            Directory.SetCurrentDirectory(Path.GetDirectoryName(ExePath));

            if (RunningOnCI)
            {
                ConsoleWrapper.WriteLine("CI Environment detected!");
            }
            else
            {
                if (runConfig == "Debug")
                {
                    Console.Title = "MEE7 - DEBUG";
                }
                else
                {
                    Console.Title = "MEE7";
                }
                //if (!RunningOnLinux)
                //    ShowWindow(GetConsoleWindow(), 2);
                Thread.CurrentThread.Name = "Main";
                Console.ForegroundColor   = ConsoleColor.White;
                Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.BelowNormal;

                handler = new ConsoleEventDelegate(ConsoleEventCallback);
                if (!RunningOnLinux)
                {
                    SetConsoleCtrlHandler(handler, true);
                }
            }

            LoadBuildDate();
            //UpdateYTDL();

            var config = new DiscordSocketConfig()
            {
                GatewayIntents      = GatewayIntents.All,
                AlwaysDownloadUsers = true,
            };

            client = new DiscordSocketClient(config);
            SetClientEvents();

            Login();

            CreateCommandInstances();

            while (!ClientReady || client.ConnectionState != ConnectionState.Connected)
            {
                Thread.Sleep(50);
            }

            SetState();

            CurrentChannel = (ISocketMessageChannel)client.GetChannel(473991188974927884);
            Thread.Sleep(1000);
            Master = client.GetUser(300699566041202699);

            DiscordNETWrapper.SendText(logStartupMessage, (IMessageChannel)GetChannelFromID(logChannel)).Wait();
            Config.Load();

            BuildHelpMenu();

            StartAutosaveLoop();

            Task.Run(() => BootTwitterModule());
            CallOnConnected();
        }
        private ICommand find_command(ChocolateyConfiguration config, Container container, bool isConsole, Action <ICommand> parseArgs)
        {
            var commands = container.GetAllInstances <ICommand>();
            var command  = commands.Where((c) =>
            {
                var attributes = c.GetType().GetCustomAttributes(typeof(CommandForAttribute), false);
                return(attributes.Cast <CommandForAttribute>().Any(attribute => attribute.CommandName.is_equal_to(config.CommandName)));
            }).FirstOrDefault();

            if (command == null)
            {
                //todo add a search among other location/extensions for the command
                if (!string.IsNullOrWhiteSpace(config.CommandName))
                {
                    throw new Exception(@"Could not find a command registered that meets '{0}'. 
 Try choco -? for command reference/help.".format_with(config.CommandName));
                }

                if (isConsole)
                {
                    Environment.ExitCode = 1;
                }
            }
            else
            {
                if (parseArgs != null)
                {
                    parseArgs.Invoke(command);
                }

                if (command.may_require_admin_access())
                {
                    warn_when_admin_needs_elevation(config);
                }

                set_source_type(config);
                // guaranteed that all settings are set.
                EnvironmentSettings.set_environment_variables(config);

                this.Log().Debug(() => "Configuration: {0}".format_with(config.ToString()));


                if (isConsole && config.HelpRequested)
                {
#if DEBUG
                    Console.WriteLine("Press enter to continue...");
                    Console.ReadKey();
#endif
                    Environment.Exit(1);
                }

                var token = Assembly.GetExecutingAssembly().get_public_key_token();
                if (string.IsNullOrWhiteSpace(token) || !token.is_equal_to(ApplicationParameters.OfficialChocolateyPublicKey))
                {
                    if (!config.AllowUnofficialBuild)
                    {
                        throw new Exception(@"
Custom unofficial builds are not allowed by default.
 To override this behavior, explicitly set --allow-unofficial.
 See the help menu (choco -h) for options.");
                    }
                    else
                    {
                        this.Log().Warn(ChocolateyLoggers.Important, @"
Chocolatey is not an official build (bypassed with --allow-unofficial).
 If you are seeing this message and it is not expected, your system may 
 now be in a bad state. Only official builds are to be trusted.
"
                                        );
                    }
                }
            }

            return(command);
        }
Beispiel #57
0
        // Compute the site ID, for both the top level function API case and the regular nested case
        private FunctionEnvelope AddFunctionAppIdToEnvelope(FunctionEnvelope function)
        {
            Uri referrer = Request.Headers.Referrer;

            if (referrer == null)
            {
                return(function);
            }

            string armId = referrer.AbsolutePath;

            const string msWeb            = "Microsoft.Web";
            const string functionResource = msWeb + "/functions";
            const string sitesResource    = msWeb + "/sites";

            // Input: /subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.Web/functions/{funcname}
            int index = armId.IndexOf(functionResource, StringComparison.OrdinalIgnoreCase);

            if (index > 0)
            {
                // Produce: /subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.Web/sites/{sitename}
                function.FunctionAppId = $"{armId.Substring(0, index)}{sitesResource}/{Environment.GetEnvironmentVariable("WEBSITE_SITE_NAME")}";
                return(function);
            }

            // Input: /subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.Web/sites/{sitename}/functions/{funcname}
            index = armId.IndexOf(sitesResource, StringComparison.OrdinalIgnoreCase);
            if (index > 0)
            {
                // Produce: /subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.Web/sites/{sitename}
                index = armId.IndexOf("/", index + sitesResource.Length + 1, StringComparison.OrdinalIgnoreCase);
                function.FunctionAppId = armId.Substring(0, index);
                return(function);
            }

            return(function);
        }
Beispiel #58
0
        internal static string ResolveMSBuildPath()
        {
            string windir = SystemEnvironment.GetFolderPath(SystemEnvironment.SpecialFolder.Windows);

            return(Path.Combine(windir, @"Microsoft.NET", "Framework", "v4.0.30319", "MSBuild.exe"));
        }
Beispiel #59
0
        internal static string ResolveHgPath()
        {
            string programFiles32 = SystemEnvironment.GetFolderPath(SystemEnvironment.SpecialFolder.ProgramFilesX86);
            string path           = Path.Combine(programFiles32, "Mercurial", "hg.exe");

            if (!File.Exists(path))
            {
                string programFiles = SystemEnvironment.GetEnvironmentVariable(ProgramFiles64bitKey) ?? SystemEnvironment.GetFolderPath(SystemEnvironment.SpecialFolder.ProgramFiles);
                path = Path.Combine(programFiles, "Mercurial", "hg.exe");

                if (!File.Exists(path))
                {
                    throw new InvalidOperationException(Resources.Error_FailedToLocateHg);
                }
            }

            return(path);
        }
Beispiel #60
0
 string GetDocsPath()
 {
     return(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments));
 }