Ejemplo n.º 1
0
        private static VersionCheckResult InternalCheck(bool displayErrors)
        {
            try
            {
                var url = VERSION_MANIFEST_URL + "?q=" + Guid.NewGuid().ToString();
                var wr  = WebRequest.CreateHttp(url);
                wr.Proxy   = ProxyCache.GetProxy(url);
                wr.Timeout = 5000;

                using (var response = wr.GetResponse())
                {
                    using (var reader = new System.IO.StreamReader(response.GetResponseStream(), Encoding.UTF8))
                    {
                        var availableBuildString = reader.ReadToEnd();
                        AvailableBuild = Version.Parse(availableBuildString);

                        return(CurrentBuild.DetermineUpdate(AvailableBuild));
                    }
                }
            }
            catch (Exception ex)
            {
                if (displayErrors)
                {
                    MessageBox.Show(ex.Message, "Unable to check for updated versions", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
                return(VersionCheckResult.Unknown);
            }
        }
Ejemplo n.º 2
0
 /// <summary>
 /// Check if this is the first launch for a particular build number.
 /// Useful if you want to execute some code for first time launches of a particular version
 /// (like db migrations?).
 /// </summary>
 /// <returns>The first launch for build.</returns>
 /// <param name="build">Build.</param>
 public bool FirstLaunchForBuild(string build) =>
 (CurrentBuild.Equals(build, StringComparison.OrdinalIgnoreCase)) && isFirstLaunchForBuild;
Ejemplo n.º 3
0
        private static async IAsyncEnumerable <DockerfileBuild> ReadCommands(TextReader reader, HashSet <string> unconsumedBuildArgs, IReadOnlyDictionary <string, string> buildArgs)
        {
            var          multiBuildArgs = new Dictionary <string, string>();
            CurrentBuild?currentBuild   = null;

            var parseOptions = new ParseOptions(multiBuildArgs);

            await foreach (var line in ReadLines(reader, parseOptions))
            {
                var(cmd, flags, args) = SplitCommand(line);

                if (cmd == "from")
                {
                    if (currentBuild != null)
                    {
                        yield return(currentBuild.ToDockerfileBuild());
                    }

                    var fromCommand = CommandParsers.From(args, flags, parseOptions);
                    currentBuild = new CurrentBuild(
                        fromCommand: fromCommand,
                        buildArgs: new Dictionary <string, string>(),
                        commands: new List <CommandBase>()
                        );
                }
                else if (cmd == "arg")
                {
                    var argCommand = CommandParsers.Arg(args, flags, parseOptions);
                    unconsumedBuildArgs.Remove(argCommand.Name);

                    if (currentBuild == null)
                    {
                        string?value;

                        if (!buildArgs.TryGetValue(argCommand.Name, out value))
                        {
                            value = argCommand.DefaultValue;
                        }

                        if (value == null)
                        {
                            multiBuildArgs.Remove(argCommand.Name);
                        }
                        else
                        {
                            multiBuildArgs[argCommand.Name] = value;
                        }
                    }
                    else
                    {
                        string?value;

                        if (!buildArgs.TryGetValue(argCommand.Name, out value) && !multiBuildArgs.TryGetValue(argCommand.Name, out value))
                        {
                            value = argCommand.DefaultValue;
                        }

                        if (value == null)
                        {
                            currentBuild.BuildArgs.Remove(argCommand.Name);
                        }
                        else
                        {
                            currentBuild.BuildArgs[argCommand.Name] = value;
                        }
                    }
                }
                else
                {
                    if (currentBuild == null)
                    {
                        throw new DockerfileSyntaxException("Command '{cmd}' may not precede 'from'.");
                    }

                    currentBuild.Commands.Add(ParseCommand(cmd, flags, args, parseOptions));
                }
            }

            if (currentBuild != null)
            {
                yield return(currentBuild.ToDockerfileBuild());
            }
        }