Ejemplo n.º 1
0
        /// <summary>
        /// Triggers a registry scan to determine the currently installed LabVIEW versions.
        /// This method is automatically invoked by the static constructor.
        /// </summary>
        public static void Scan()
        {
            // Initialize Versions List
            Versions       = new List <lvVersion>();
            CurrentVersion = null;

            // Scan 32bit Registry
            _ScanRegistry(RegistryView.Registry32);

            // Scan 64bit Registry on x64 Systems
            if (Environment.Is64BitOperatingSystem)
            {
                _ScanRegistry(RegistryView.Registry64);
            }

            // Determine Current Version (default if no exe or version is supplied as argument)
            _GetCurrentVersion();

            Output output = Output.Instance;

            if (CurrentVersion == null)
            {
                output.writeInfo("No installed LabVIEW version discovered!");
            }
            else
            {
                output.writeInfo("Current Version: " + CurrentVersion.ToString());

                output.writeInfo("Detected LabVIEW versions:");
                foreach (var current in Versions)
                {
                    output.writeInfo(current.ToString() + "(" + current.Path + ")");
                }
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Determines the default LabVIEW version.
        /// Favours 32bit over 64bit version, if both coexist
        /// Falls back to using the first entry of the versions list,
        /// </summary>
        private static void _GetCurrentVersion()
        {
            // don't proceed if the scans did not discover any lv versions
            if (Versions.Count <= 0)
            {
                return;
            }

            // check 32bit key
            _CheckCurrentVersionKey(RegistryView.Registry32);
            if (CurrentVersion != null)
            {
                return; //exit if found
            }
            // check 64bit
            if (Environment.Is64BitOperatingSystem)
            {
                _CheckCurrentVersionKey(RegistryView.Registry64);
            }
            if (CurrentVersion != null)
            {
                return; //exit if found
            }
            // use first entry in Versions
            CurrentVersion = Versions.First();
        }
Ejemplo n.º 3
0
        //This function will complete the launch path to a file in the search directory if it doesn't
        //exist locally. If it exists locally it will do nothing.
        private string substituteSearchPath(string launchPath, lvVersion labview)
        {
            string searchPath;

            searchPath = Path.Combine(labview.ToolsPath, launchPath);
            output.writeDebug(String.Format("Looks like the requested VI {0} Doesnt Exist. Checking In Search Path Instead: {1}", launchPath, searchPath));
            return(searchPath);
        }
Ejemplo n.º 4
0
        public void registerPort(string viPath, lvVersion lvVer, int port)
        {
            CreateLaunchID(viPath, lvVer);

            string baseResponse = "=HTTP/1.0 200 OK\r\nServer: Service Locator\r\nPragma: no-cache\r\nConnection: Close\r\nContent-Length: 12\r\nContent-Type: text/html\r\n\r\nPort=";
            string url          = "http://localhost:3580/publish?" + _launchID + baseResponse + port + "\r\n";

            HttpResponseMessage response = _httpClient.GetAsync(Uri.EscapeUriString(url)).Result;

            _registered = true;
        }
Ejemplo n.º 5
0
        public string CreateLaunchID(string viPath, lvVersion lvVer)
        {
            //convert to full path since LabVIEW doesn't know our CWD
            string fullViPath = Path.GetFullPath(viPath);

            Regex  forbiddenCharacters = new Regex(@"[:\\.\s]");
            string viPathEscaped       = forbiddenCharacters.Replace(fullViPath, "");

            _launchID = "cli/" + lvVer.Version.Substring(0, 4) + '/' + lvVer.Bitness + '/' + viPathEscaped;

            return(_launchID);
        }
Ejemplo n.º 6
0
        public LvLauncher(string launchPath, lvVersion lvVer, int port, portRegistration portRegistration)
        {
            procInfo = new ProcessStartInfo();

            string arguments = "-unattended -- -p:" + port;

            if (isExe(launchPath))
            {
                procInfo.FileName  = launchPath;
                procInfo.Arguments = arguments;
            }
            else
            {
                //gate on a blank LV path which means we don't have LabVIEW Installed.
                if (lvVer.ExePath == "")
                {
                    throw new System.IO.FileNotFoundException("No LabVIEW.exe found...", "LabVIEW.exe");
                }


                if (!File.Exists(launchPath))
                {
                    //The file doesn't exist. Check search directory.
                    launchPath = substituteSearchPath(launchPath, lvVer);

                    if (!File.Exists(launchPath))
                    {
                        //Still doesn't exists - throw exception.
                        throw new FileNotFoundException("Launch path does not exist locally or in the the tools directory", launchPath);
                    }
                }



                procInfo.FileName  = lvVer.ExePath;
                procInfo.Arguments = "\"" + launchPath + "\" " + arguments;
                portRegistration.registerPort(launchPath, lvVer, port);
            }

            lvProcess           = new Process();
            lvProcess.StartInfo = procInfo;
        }
Ejemplo n.º 7
0
        private static void _CheckCurrentVersionKey(RegistryView view)
        {
            RegistryKey currentKey = _GetBaseKey(view).OpenSubKey("CurrentVersion");

            if (currentKey != null)
            {
                object GUID = currentKey.GetValue("GUID");
                if (GUID != null)
                {
                    foreach (lvVersion current in Versions)
                    {
                        if (current.GUID == GUID.ToString())
                        {
                            CurrentVersion = current;
                            break;
                        }
                    }
                }
            }
        }
Ejemplo n.º 8
0
        static int Main(string[] args)
        {
            Output output = Output.Instance;

            string[]         cliArgs, lvArgs;
            lvComms          lvInterface      = new lvComms();
            lvMsg            latestMessage    = new lvMsg("NOOP", "");
            LvLauncher       launcher         = null;
            CliOptions       options          = new CliOptions();
            lvVersion        current          = LvVersions.CurrentVersion;
            portRegistration portRegistration = new portRegistration();

            splitArguments(args, out cliArgs, out lvArgs);
            if (!CommandLine.Parser.Default.ParseArguments(cliArgs, options))
            {
                Environment.Exit(CommandLine.Parser.DefaultExitCodeFail);
            }
            if (options.Version)
            {
                output.writeMessage(getVersionString());
                Environment.Exit(0);
            }

            output.setVerbose(options.Verbose);
            output.writeInfo("G CLI Started - Verbose Mode");
            output.writeInfo("Version " + getVersionString());
            output.writeInfo("G CLI Arguments: " + String.Join(" ", cliArgs));
            output.writeInfo("Arguments passed to LabVIEW: " + String.Join(" ", lvArgs));

            //Warn about deprecated option.
            if (options.lvExe != null)
            {
                output.writeError("--lv-exe option is deprecated. Alter the script to use --lv-ver. Default will be used this time.");
            }

            //Force a rescan at this point to get an output - the constructor scan does not seem to write to output, possibly due to happening before we set verbose flag.
            LvVersions.Scan();

            if (options.noLaunch)
            {
                output.writeMessage("Auto Launch Disabled");
                // disable timeout if noLaunch is specified
                options.timeout = -1;
            }
            else
            {
                // check launch vi
                if (options.LaunchVI == null)
                {
                    output.writeError("No launch VI supplied!");
                    return(1);
                }

                /*
                 * if (!File.Exists(options.LaunchVI))
                 * {
                 *  output.writeError("File \"" + options.LaunchVI + "\" does not exist!");
                 *  return 1;
                 * }
                 */

                //Add VI extension if none specified.
                if (!Path.HasExtension(options.LaunchVI))
                {
                    output.writeInfo("No extension so assuming .vi");
                    options.LaunchVI = options.LaunchVI + ".vi";
                }

                List <string> permittedExtensions = new List <string> {
                    ".vi", ".lvproj", ".exe"
                };
                string ext = Path.GetExtension(options.LaunchVI).ToLower();
                if (!permittedExtensions.Contains(ext))
                {
                    output.writeError("Cannot handle *" + ext + " files");
                    return(1);
                }

                try
                {
                    launcher         = new LvLauncher(options.LaunchVI, lvPathFinder(options), lvInterface.port, portRegistration);
                    launcher.Exited += Launcher_Exited;
                    launcher.Start();
                }
                catch (KeyNotFoundException ex)
                {
                    // Fail gracefully if lv-ver option cannot be resolved
                    string bitness = options.x64 ? " 64bit" : string.Empty;
                    output.writeError("LabVIEW version \"" + options.lvVer + bitness + "\" not found!");
                    output.writeMessage("Available LabVIEW versions are:");
                    foreach (var ver in LvVersions.Versions)
                    {
                        output.writeMessage(ver.ToString());
                    }
                    return(1);
                }
                catch (FileNotFoundException ex)
                {
                    output.writeError("ERROR: Missing File: " + ex.Message);
                    return(1);
                }
            }

            //At this point LV should have launched so now we need to handle Ctrl+C to ensure LV is killed as well.
            Console.CancelKeyPress += delegate(object sender, ConsoleCancelEventArgs e)
            {
                output.writeMessage("Cancel key received, closing LabVIEW.");
                launcher.Kill();
            };

            // wait for the LabVIEW application to connect to the cli
            connected = lvInterface.waitOnConnection(options.timeout);
            portRegistration.unRegister();

            // if timed out, kill LabVIEW and exit with error code
            if (!connected && launcher != null)
            {
                output.writeError("Connection to LabVIEW timed out!");
                launcher.Kill();
                launcher.Exited -= Launcher_Exited;
                return(1);
            }
            else
            {
                output.writeInfo("Client Connected");
            }

            //Write the use arguments
            lvInterface.writeInitialMessages(lvArgs, Directory.GetCurrentDirectory());

            while (!stop)
            {
                //strange call because it is async method.
                latestMessage = lvInterface.readMessage().GetAwaiter().GetResult();

                switch (latestMessage.messageType)
                {
                case "OUTP":
                    Console.Write(latestMessage.messageData);
                    break;

                case "EXIT":
                    exitCode = lvInterface.extractExitCode(latestMessage.messageData);
                    output.writeInfo("Received Exit Code " + exitCode);
                    stop = true;
                    break;

                case "RDER":
                    exitCode = 1;
                    output.writeError("Read Error");
                    if (latestMessage.messageData != "")
                    {
                        output.writeError(": " + latestMessage.messageData);
                    }
                    output.writeError("Since the network stream will be out of sync the application will now exit.");
                    stop = true;
                    break;

                default:
                    output.writeError("Unknown Message Type Received:" + latestMessage.messageType);
                    break;
                }
            }
            ;

            // close tcp listener
            lvInterface.Close();

            // if killswitch is set, force LabVIEW to exit if it has not closed by itself after a 10s timeout (or the period specified in --timeout)
            if (options.kill)
            {
                int timeout = options.timeout == -1 ? 10000 : options.timeout;
                if (!launcher.lvExited.Wait(timeout))
                {
                    output.writeMessage("Forcing LabVIEW to terminate...");
                    launcher.Kill();
                }
            }

            launcher.Close();

            return(exitCode);
        }