Ejemplo n.º 1
0
        private void Stop()
        {
            // kill the start button so we don't get a start
            // signal before completely stopped.
            ButtonStart.Enabled = false;

            // revert the host file modification, if necessary
            if (AddHost && RunState == RunState.Running)
            {
                HostsFile.RemoveHostEntry(_server.IPAddress.ToString(), _server.HostName);
            }

            if (_server != null)
            {
                _server.TimedOut -= OnTimedOut;
                _server.Dispose();
            }

            RootUrl = string.Empty;

            InvokeSetRunState(RunState.Idle);

            if (_automated)
            {
                ExitApp();
            }
        }
Ejemplo n.º 2
0
        private void Start()
        {
            // use CommandLineArguments as a pre validation tool

            CommandLineArguments args = GetArgs();

            ClearError();

            try
            {
                args.Validate();
            }

            catch (CassiniException ex)
            {
                SetError(ex.Field, ex.Message);
                return;
            }

            IPAddress = args.IPAddress;

            Port = args.Port;

            HostName = args.HostName;

            _server = new Server(args.Port, args.VirtualPath, args.ApplicationPath,
                                 System.Net.IPAddress.Parse(args.IPAddress), args.HostName, args.TimeOut, args.Ntlm,
                                 args.Nodirlist);

            if (args.AddHost)
            {
                HostsFile.AddHostEntry(_server.IPAddress.ToString(), _server.HostName);
            }

            try
            {
                _server.Start();
                _server.TimedOut += OnTimedOut;
                UpdateUIFromServer();
                InvokeSetRunState(RunState.Running);
            }

            catch (Exception ex)
            {
                SetError(ErrorField.None, ex.Message);
                _server.Dispose();
            }
        }
Ejemplo n.º 3
0
 private static void SetHostsFile(CommandLineArguments sargs)
 {
     try
     {
         if (sargs.AddHost)
         {
             HostsFile.AddHostEntry(sargs.IPAddress, sargs.HostName);
         }
         else
         {
             HostsFile.RemoveHostEntry(sargs.IPAddress, sargs.HostName);
         }
     }
     catch (UnauthorizedAccessException)
     {
         Environment.Exit(-1);
     }
     catch
     {
         Environment.Exit(-2);
     }
 }
        static void Main(string[] paras)
        {
            int    port = 12345;
            string path = @"C:\";

            if (paras.Length == 0)
            {
                #region [ === RUN VIA CONSOLE === ]

                path               = //@"D:\WebUI\webui\dev\source\study\www";// Environment.CurrentDirectory;
                              path = Environment.CurrentDirectory;

                TcpListener l = new TcpListener(IPAddress.Loopback, 0);
                l.Start();
                port = ((IPEndPoint)l.LocalEndpoint).Port;
                l.Stop();

                var server = new Server(port, "/", path, false, false);
                // HostsFile.AddHostEntry(server.IPAddress.ToString(), server.HostName);

                try
                {
                    server.Start();
                    Console.Title = port.ToString();
                    string url    = string.Format("http://*****:*****@"D:\ChromeDoc\GoogleChromePortable.exe";
                    if (!File.Exists(chrome))
                    {
                        chrome = "chrome.exe";
                    }
                    Process.Start(chrome, url);
                    Console.WriteLine(path);
                }
                catch (Exception ex)
                {
                    Console.WriteLine("[ERROR]");
                    //Console.WriteLine("ERROR: " + ex.Message);
                }

                Console.ReadLine();

                #endregion
            }
            else
            {
                #region [  === RUN VIA PROCESS === ]

                if (paras.Length > 1)
                {
                    int.TryParse(paras[0], out port);
                    path = paras[1];
                }

                string pr = string.Join("||", paras);
                Console.WriteLine(pr);

                CommandLineArguments args = new CommandLineArguments()
                {
                    Port            = port,
                    VirtualPath     = "/",
                    ApplicationPath = path,
                    Ntlm            = false,
                    Nodirlist       = false,
                };

                var server = new Server(args.Port, args.VirtualPath, args.ApplicationPath, args.Ntlm, args.Nodirlist);

                if (args.AddHost)
                {
                    HostsFile.AddHostEntry(server.IPAddress.ToString(), server.HostName);
                }

                try
                {
                    server.Start();
                    Console.WriteLine("[BEGIN]");
                }
                catch (Exception ex)
                {
                    Console.WriteLine("[ERROR]");
                    //Console.WriteLine("ERROR: " + ex.Message);
                }

                //Console.ReadLine();
                while (true)
                {
                    ;
                }

                #endregion
            }
        }
Ejemplo n.º 5
0
        private static void Main(string[] cmdLine)
        {
            CommandLineArguments args = new CommandLineArguments();


            if (!CommandLineParser.ParseArgumentsWithUsage(cmdLine, args))
            {
                Environment.Exit(-1);
            }
            else
            {
                switch (args.RunMode)
                {
                case RunMode.Server:
                    IPAddress ip = IPAddress.Loopback;
                    try
                    {
                        args.Validate();

                        ip = CommandLineArguments.ParseIP(args.IPMode, args.IPv6, args.IPAddress);
                        int port = args.PortMode == PortMode.FirstAvailable ?
                                   CassiniNetworkUtils.GetAvailablePort(args.PortRangeStart, args.PortRangeEnd, ip, true) :
                                   args.Port;

                        if (args.AddHost)
                        {
                            HostsFile.AddHostEntry(ip.ToString(), args.HostName);
                        }

                        using (var server =
                                   new Server(port, args.VirtualPath, args.ApplicationPath,
                                              ip, args.HostName, args.TimeOut))
                        {
                            server.Start();
                            Console.WriteLine("started: {0}\r\nPress Enter key to exit....", server.RootUrl);
                            Console.ReadLine();
                            server.ShutDown();
                        }
                    }
                    catch (CassiniException ex)
                    {
                        Console.WriteLine("error:{0} {1}",
                                          ex.Field == ErrorField.None
                                                  ? ex.GetType().Name
                                                  : ex.Field.ToString(), ex.Message);
                    }
                    catch (Exception ex2)
                    {
                        Console.WriteLine("error:{0}", ex2.Message);
                        Console.WriteLine(CommandLineParser.ArgumentsUsage(typeof(CommandLineArguments)));
                    }
                    finally
                    {
                        if (args.AddHost)
                        {
                            HostsFile.RemoveHostEntry(ip.ToString(), args.HostName);
                        }
                    }
                    break;

                case RunMode.Hostsfile:
                    SetHostsFile(args);
                    break;
                }
            }
        }
Ejemplo n.º 6
0
        public static int Main(string[] cmdLine)
        {
            Server server = null;

            if (cmdLine != null && cmdLine.Length > 0)
            {
                bool isVS = Assembly.GetExecutingAssembly()
                            .GetName().Name.StartsWith("WEBDEV.WEBSERVER", StringComparison.OrdinalIgnoreCase);

                CommandLineArguments args = new CommandLineArguments();

                if (!CommandLineParser.ParseArgumentsWithUsage(cmdLine, args))
                {
                    if (isVS)
                    {
                        // will display vs usage and return a code that VS understands
                        return(ValidateForVS(cmdLine));
                    }

                    string usage = CommandLineParser.ArgumentsUsage(typeof(CommandLineArguments), 120);
                    ShowMessage(usage, MessageBoxIcon.Asterisk);
                    return(0);
                }


                if (args.RunMode == RunMode.Hostsfile)
                {
                    SetHostsFile(args);
                    return(0);
                }


                // now we validate for us.
                int    returnValue = -1;
                string message     = null;

                try
                {
                    args.VisualStudio = isVS;
                    args.Validate();
                }
                catch (CassiniException ex)
                {
                    switch (ex.Message)
                    {
                    case SR.ErrNoAvailablePortFound:
                    case SR.ErrApplicationPathIsNull:
                        message = ex.Message;
                        break;

                    case SR.ErrInvalidIPMode:
                        message = SR.GetString(ex.Message, args.IPMode);
                        break;

                    case SR.ErrInvalidPortMode:
                        message = SR.GetString(ex.Message, args.PortMode);
                        break;

                    case SR.ErrPortIsInUse:
                        message = SR.GetString(ex.Message, args.Port);
                        break;

                    case SR.ErrPortRangeEndMustBeEqualOrGreaterThanPortRangeSta:
                        message = SR.GetString(ex.Message, args.PortRangeStart, args.PortRangeEnd);
                        break;

                    case SR.ErrInvalidPortRangeValue:
                        message = SR.GetString(ex.Message,
                                               ex.Field == ErrorField.PortRangeStart
                                                       ? "start " + args.PortRangeStart
                                                       : "end " + args.PortRangeEnd);
                        break;

                    case SR.ErrInvalidHostname:
                        message = SR.GetString(ex.Message, args.HostName);
                        break;

                    case SR.WebdevDirNotExist:
                        message     = SR.GetString(ex.Message, args.ApplicationPath);
                        returnValue = -2;
                        break;

                    case SR.ErrPortOutOfRange:
                        message = SR.GetString(ex.Message, args.Port);
                        break;
                    }

                    if (!args.Silent)
                    {
                        ShowMessage(message, MessageBoxIcon.Asterisk);
                    }
                    return(returnValue);
                }
                catch (Exception exception)
                {
                    if (!args.Silent)
                    {
                        ShowMessage(SR.GetString(SR.ErrFailedToStartCassiniDevServerOnPortError, args.Port,
                                                 exception.Message, exception.HelpLink), MessageBoxIcon.Error);
                    }
                    return(-1);
                }



                server = new Server(args.Port, args.VirtualPath, args.ApplicationPath, args.Ntlm, args.Nodirlist);


                if (args.AddHost)
                {
                    HostsFile.AddHostEntry(server.IPAddress.ToString(), server.HostName);
                }

                try
                {
                    server.Start();
                }
                catch (Exception exception)
                {
                    if (!args.Silent)
                    {
                        ShowMessage(SR.GetString(SR.ErrFailedToStartCassiniDevServerOnPortError, args.Port,
                                                 exception.Message, exception.HelpLink), MessageBoxIcon.Error);
                    }
                    return(-4);
                }
            }

            using (FormView form = new FormView(server))
            {
                Application.Run(form);
            }

            return(0);
        }