Ejemplo n.º 1
0
        /// <summary>
        /// Try to auto-detect which parser is suitable given a system string.
        /// </summary>
        public void Init(FtpOperatingSystem system, FtpParser defaultParser)
        {
            ParserConfirmed = false;

            if (system == FtpOperatingSystem.Windows)
            {
                CurrentParser = FtpParser.Windows;
            }
            else if (system == FtpOperatingSystem.Unix)
            {
                CurrentParser = FtpParser.Unix;
            }
            else if (system == FtpOperatingSystem.VMS)
            {
                CurrentParser = FtpParser.VMS;
            }
            else if (system == FtpOperatingSystem.IBMOS400)
            {
                CurrentParser = FtpParser.IBM;
            }
            else
            {
                CurrentParser = defaultParser;
                client.LogStatus(FtpTraceLevel.Warn, "Cannot auto-detect listing parser for system '" + system + "', using " + defaultParser + " parser");
            }

            DetectedParser = CurrentParser;
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Validate if the current parser is correct
        /// </summary>
        private bool IsParserValid(FtpParser p, string[] files)
        {
            switch (p)
            {
            case FtpParser.Windows:
                return(FtpWindowsParser.IsValid(client, files));

            case FtpParser.Unix:
                return(FtpUnixParser.IsValid(client, files));

            case FtpParser.VMS:
                return(FtpVMSParser.IsValid(client, files));

            case FtpParser.IBMzOS:
                return(FtpIBMzOSParser.IsValid(client, files));

            case FtpParser.IBMOS400:
                return(FtpIBMOS400Parser.IsValid(client, files));

            case FtpParser.NonStop:
                return(FtpNonStopParser.IsValid(client, files));
            }

            return(false);
        }
        public void ReturnTwoParticularSongs()
        {
            Mock <IFtpLoader> mock = new Mock <IFtpLoader>();

            mock.Setup(m => m.GetContent()).Returns(Task.FromResult(File.ReadAllText("ftpData")));
            FtpParser ftpParser = new FtpParser(mock.Object);

            ftpParser.Parse("DISCO");
            var expected = new[]
            {
                new {
                    Title           = "Kenji Ninuma - DISCO★PRINCE.osz",
                    LinkToThumbnail = "//b.ppy.sh/thumb/1l.jpg",
                    DownloadLink    = "ftp//gildiagrzybiarzy.pl/osu!/1 Kenji Ninuma - DISCO★PRINCE.osz.osz"
                },
                new {
                    Title           = "Pastel-Palettes - DISCOTHEQUE.osz",
                    LinkToThumbnail = "//b.ppy.sh/thumb/919813l.jpg",
                    DownloadLink    = "ftp//gildiagrzybiarzy.pl/osu!/919813 Pastel-Palettes - DISCOTHEQUE.osz.osz"
                }
            };
            var parsedSongs    = ftpParser.RetrieveSongsList();
            var songsToCompare = parsedSongs.Select(data =>
                                                    new
            {
                data.Title,
                data.LinkToThumbnail,
                data.DownloadLink
            }).ToArray();

            CollectionAssert.AreEquivalent(expected, songsToCompare);
        }
        public void ReturnsNothingWhenPassedNull()
        {
            Mock <IFtpLoader> mock = new Mock <IFtpLoader>();

            mock.Setup(m => m.GetContent()).Returns(Task.FromResult(File.ReadAllText("ftpData")));
            FtpParser ftpParser = new FtpParser(mock.Object);

            ftpParser.Parse(null);
            var expected = new List <Model.SongsInfo>();
            var actual   = ftpParser.RetrieveSongsList();

            CollectionAssert.AreEquivalent(expected, actual);
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Validate if the current parser is correct, or if another parser seems more appropriate.
        /// </summary>
        private void ValidateParser(string[] files)
        {
            if (IsWrongParser())
            {
                // by default use the UNIX parser, if none detected
                if (DetectedParser == FtpParser.Auto)
                {
                    DetectedParser = FtpParser.Unix;
                }

                if (CurrentParser == FtpParser.Auto)
                {
                    CurrentParser = DetectedParser;
                }

                // if machine listings not supported, switch to UNIX parser
                if (IsWrongMachineListing())
                {
                    CurrentParser = DetectedParser;
                }

                // use the initially set parser (from SYST)
                if (IsParserValid(CurrentParser, files))
                {
                    client.LogStatus(FtpTraceLevel.Verbose, "Confirmed format " + CurrentParser.ToString());
                    ParserConfirmed = true;
                    return;
                }

                foreach (var p in parsers)
                {
                    if (IsParserValid(p, files))
                    {
                        CurrentParser = p;
                        client.LogStatus(FtpTraceLevel.Verbose, "Detected format " + CurrentParser.ToString());
                        ParserConfirmed = true;
                        return;
                    }
                }

                CurrentParser = FtpParser.Unix;
                client.LogStatus(FtpTraceLevel.Verbose, "Could not detect format. Using default " + CurrentParser.ToString());
            }
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Try to auto-detect which parser is suitable given a system string.
        /// </summary>
        public void Init(FtpOperatingSystem system, FtpParser forcedParser = FtpParser.Auto)
        {
            ParserConfirmed = false;

            if (forcedParser != FtpParser.Auto)
            {
                // use the parser that the server handler specified
                CurrentParser = forcedParser;
            }
            else
            {
                if (system == FtpOperatingSystem.Windows)
                {
                    CurrentParser = FtpParser.Windows;
                }
                else if (system == FtpOperatingSystem.Unix || system == FtpOperatingSystem.SunOS)
                {
                    CurrentParser = FtpParser.Unix;
                }
                else if (system == FtpOperatingSystem.VMS)
                {
                    CurrentParser = FtpParser.VMS;
                }
                else if (system == FtpOperatingSystem.IBMzOS)
                {
                    CurrentParser = FtpParser.IBMzOS;
                }
                else if (system == FtpOperatingSystem.IBMOS400)
                {
                    CurrentParser = FtpParser.IBMOS400;
                }
                else
                {
                    CurrentParser = FtpParser.Unix;
                    client.LogStatus(FtpTraceLevel.Warn, "Cannot auto-detect listing parser for system '" + system + "', using Unix parser");
                }
            }

            DetectedParser = CurrentParser;

            client.LogStatus(FtpTraceLevel.Verbose, "Listing parser set to: " + DetectedParser.ToString());
        }