Esempio n. 1
0
        private void RefreshDiff()
        {
            Data.NewConfigLines = VyattaConfigUtil.WriteToStringLines(Data.ConfigRoot);

            var Diff       = new Menees.Diffs.TextDiff(HashType.HashCode, false, false, 0, false);
            var EditScript = Diff.Execute(Data.OldConfigLines, Data.NewConfigLines);

            ConfigDiff.SetData(Data.OldConfigLines, Data.NewConfigLines, EditScript, "Existing router config", "New router config", false, true, false);
            ConfigDiff.GoToFirstDiff();
        }
        public bool DoWork(Util.UpdateStatusDelegate SetStatus, Util.ShouldCancelDelegate ShouldCancel)
        {
            if (ShouldCancel())
            {
                return(false);
            }

            SetStatus("Connecting to SSH...", 0);

            using (VyattaShell Shell = new VyattaShell(Data.Address, Data.Username, Data.Password))
            {
                if (ShouldCancel())
                {
                    return(false);
                }

                //Verify that we can identify the device

                SetStatus("Identifying device...", 5);

                var Version = Shell.RunCommand("cat /proc/version");
                if (!Version.Contains("edgeos"))
                {
                    throw new Exception("The device is not running EdgeOS and is not supported. Device ");
                }

                if (ShouldCancel())
                {
                    return(false);
                }

                //Enter configure mode

                SetStatus("Processing routing interfaces...", 8);

                Dictionary <string, string> Gateways = IPRoute.GetDefaultGateways(Shell);

                SetStatus("Processing interface list...", 16);
                string ShowInterfaces = Shell.RunCommand("show interfaces");

                Regex ParseInterfaces = new Regex(@"([\w\.]+)\s+([0-9.\-]+(:?\/[0-9]+)?)\s+(\w\/\w)\s+(\w+)?");

                Data.Interfaces = new ObservableCollection <InterfaceMapping>();

                string[] InterfaceLines = ShowInterfaces.Split(new char[] { '\n' });
                foreach (string Line in InterfaceLines)
                {
                    Match Match = ParseInterfaces.Match(Line);
                    if (Match.Success)
                    {
                        InterfaceMapping Mapping = new InterfaceMapping();

                        Mapping.Interface   = Match.Groups[1].Value;
                        Mapping.IPAddress   = Match.Groups[2].Value == "-" ? "" : Match.Groups[2].Value;
                        Mapping.Codes       = Match.Groups[4].Value;
                        Mapping.Description = Match.Groups[5].Value;

                        string Gateway;
                        if (Gateways.TryGetValue(Mapping.Interface, out Gateway))
                        {
                            Mapping.Gateway = Gateway;
                        }

                        Data.Interfaces.Add(Mapping);
                    }
                }
            }

            SetStatus("Connecting over SCP...", 60);

            if (ShouldCancel())
            {
                return(false);
            }

            using (ScpClient Client = new ScpClient(Data.Address, Data.Username, Data.Password))
            {
                Client.Connect();

                if (ShouldCancel())
                {
                    return(false);
                }

                SetStatus("Downloading config...", 80);

                using (Stream tempFile = new FileStream(TempPath, FileMode.CreateNew))
                {
                    Client.Download("/config/config.boot", tempFile);
                }

                SetStatus("Parsing existing config...", 85);

                string Errors = "";
                Data.OldConfigLines = File.ReadAllLines(TempPath);
                Data.ConfigRoot     = VyattaConfigUtil.ReadFromFile(TempPath, ref Errors);
                if (Errors.Length > 0)
                {
                    throw new Exception(Errors);
                }

                SetStatus("Downloading current template...", 90);

                try
                {
                    using (Stream tempTemplateFile = new FileStream(TempTemplatePath, FileMode.CreateNew))
                    {
                        Client.Download("/config/vcu/current.vcu", tempTemplateFile);
                    }

                    SetStatus("Parsing current template...", 95);

                    Errors            = "";
                    Data.TemplateRoot = VyattaConfigUtil.ReadFromFile(TempTemplatePath, ref Errors);
                    if (Errors.Length > 0)
                    {
                        throw new Exception(Errors);
                    }
                }
                catch (SshException e)
                {
                    if (!e.Message.Contains("No such file or directory"))
                    {
                        throw e;
                    }

                    //It's quite okay to fail here, it means the user hasn't uploaded
                    //a config with the tool yet.

                    Data.TemplateRoot = new VyattaConfigObject(null);
                }

                if (ShouldCancel())
                {
                    return(false);
                }

                SetStatus("Disconnecting...", 98);

                Client.Disconnect();
            }

            SetStatus("Completed.", 100);

            return(true);
        }
        public bool DoWork(Util.UpdateStatusDelegate SetStatus, Util.ShouldCancelDelegate ShouldCancel)
        {
            SetStatus("Connecting to SSH...", 0);

            using (VyattaShell Shell = new VyattaShell(Data.Address, Data.Username, Data.Password))
            {
                SetStatus("Creating backup...", 5);
                Shell.RunCommand("mkdir /config/vcu");
                Shell.RunCommand("cp /config/config.boot /config/vcu/previous.boot");
                Shell.RunCommand("cp /config/current.vcu /config/vcu/previous.vcu");
                Shell.RunCommand(string.Format("cp /config/config.boot /config/vcu/history_{0}.boot", DateTime.Now.ToString(VyattaConfigUtil.SortableDateFormat)));
                Shell.RunCommand(string.Format("cp /config/current.vcu /config/vcu/history_{0}.vcu", DateTime.Now.ToString(VyattaConfigUtil.SortableDateFormat)));

                SetStatus("Entering configure mode...", 10);
                Shell.RunCommand("configure");

                if (!ShouldCancel())
                {
                    using (ScpClient ScpClient = new ScpClient(Data.Address, Data.Username, Data.Password))
                    {
                        string TempConfigPath = Path.ChangeExtension(Path.GetTempFileName(), Guid.NewGuid().ToString());
                        Data.NewConfigLines = VyattaConfigUtil.WriteToStringLines(Data.ConfigRoot);
                        VyattaConfigUtil.WriteToFile(Data.ConfigRoot, TempConfigPath);

                        string TempTemplatePath = Path.ChangeExtension(Path.GetTempFileName(), Guid.NewGuid().ToString());
                        VyattaConfigUtil.WriteToFile(Data.TemplateRoot, TempTemplatePath);

                        ScpClient.Connect();

                        SetStatus("Uploading new config...", 15);

                        if (!ShouldCancel())
                        {
                            using (Stream configFile = new FileStream(TempConfigPath, FileMode.Open))
                            {
                                ScpClient.Upload(configFile, "/config/config.boot");
                            }
                        }

                        //Probably shouldn't cancel after this point it might leave things in a weird state...

                        using (Stream templateFile = new FileStream(TempTemplatePath, FileMode.Open))
                        {
                            ScpClient.Upload(templateFile, "/config/current.vcu");
                        }

                        SetStatus("Disconnecting SCP...", 20);

                        ScpClient.Disconnect();
                    }
                }

                SetStatus("Loading new config...", 25);

                Shell.RunCommand("load");

                SetStatus("Comparing config...", 35);
                Shell.RunCommand("compare");

                SetStatus("Committing new config (this will take a while)...", 45);
                string CommitResult = Shell.RunCommand("commit");

                if (CommitResult.Contains("Commit failed"))
                {
                    //Restore the backup
                    Shell.RunCommand("cp /config/vcu/previous.boot /config/config.boot");

                    Shell.RunCommand("load");
                    Shell.RunCommand("commit");

                    Shell.RunCommand("exit");

                    throw new Exception(CommitResult);
                }

                SetStatus("Committing new config (this will take a while)...", 95);
                Shell.RunCommand("exit");

                SetStatus("Disconnecting from SSH...", 98);
            }

            SetStatus("Completed.", 100);

            return(true);
        }
Esempio n. 4
0
        public bool DoWork(Util.UpdateStatusDelegate SetStatus, Util.ShouldCancelDelegate ShouldCancel)
        {
            if (ShouldCancel())
            {
                return(false);
            }

            SetStatus("Deleting previous auto-generated rules...", 16);
            VyattaConfigRouting.DeleteGeneratedStaticRoutes(Data.ConfigRoot);

            if (ShouldCancel())
            {
                return(false);
            }

            SetStatus("Generating Netflix static routing...", 32);
            //VyattaConfigRouting.AddStaticRoutesForOrganization( Data.ConfigRoot, "Netflix", Data, "Internet", "Netflix" );
            {
                StaticRoutingData NewRoute = new StaticRoutingData();
                NewRoute.Destination = "Netflix";
                NewRoute.Interface   = "eth0";
                NewRoute.Name        = "Netflix";
                NewRoute.Type        = RoutingType.Organisation;
                NewRoute.Action      = StaticRouteAction.ToInterface;

                Data.StaticRoutes.Add(NewRoute);
            }

            if (ShouldCancel())
            {
                return(false);
            }

            SetStatus("Generating BBC static routing...", 48);
            //VyattaConfigRouting.AddStaticRoutesForOrganization( Data.ConfigRoot, "BBC", Data, "Internet", "BBC" );
            {
                StaticRoutingData NewRoute = new StaticRoutingData();
                NewRoute.Destination = "BBC";
                NewRoute.Interface   = "eth0";
                NewRoute.Name        = "BBC";
                NewRoute.Type        = RoutingType.Organisation;
                NewRoute.Action      = StaticRouteAction.ToInterface;

                Data.StaticRoutes.Add(NewRoute);
            }

            if (ShouldCancel())
            {
                return(false);
            }

            SetStatus("Generating Valve static routing...", 56);
            //VyattaConfigRouting.AddStaticRoutesForOrganization( Data.ConfigRoot, "Valve", Data, "Internet", "Valve" );
            {
                StaticRoutingData NewRoute = new StaticRoutingData();
                NewRoute.Destination = "Valve";
                NewRoute.Interface   = "eth0";
                NewRoute.Name        = "Valve";
                NewRoute.Type        = RoutingType.Organisation;
                NewRoute.Action      = StaticRouteAction.ToInterface;

                Data.StaticRoutes.Add(NewRoute);
            }

            if (ShouldCancel())
            {
                return(false);
            }

            SetStatus("Generating Nest static routing...", 80);
            //VyattaConfigRouting.AddStaticRoutesForOrganization( Data.ConfigRoot, "Nest", Data, "Internet", "Nest" );
            {
                StaticRoutingData NewRoute = new StaticRoutingData();
                NewRoute.Destination = "Nest";
                NewRoute.Interface   = "eth0";
                NewRoute.Name        = "Nest";
                NewRoute.Type        = RoutingType.Organisation;
                NewRoute.Action      = StaticRouteAction.ToInterface;

                Data.StaticRoutes.Add(NewRoute);
            }

            SetStatus("Saving new config...", 90);
            Data.NewConfigLines = VyattaConfigUtil.WriteToStringLines(Data.ConfigRoot);

            return(true);
        }