コード例 #1
0
        public async Task <bool> CheckMonoInstallAsync(RoboRioConnection rioConn)
        {
            await OutputWriter.Instance.WriteLineAsync("Checking for Mono install").ConfigureAwait(false);

            var retVal = await rioConn.RunCommandAsync($"test -e {DeployProperties.RoboRioMonoBin}", ConnectionUser.LvUser).ConfigureAwait(false);

            return(retVal.ExitStatus == 0);
        }
コード例 #2
0
        internal async Task DeployMonoAsync()
        {
            var writer = OutputWriter.Instance;
            await writer.ClearAsync().ConfigureAwait(false);

            //Connect to RoboRIO
            await writer.WriteLineAsync("Attempting to Connect to RoboRIO").ConfigureAwait(false);

            Task <RoboRioConnection> rioConnectionTask = RoboRioConnection.StartConnectionTaskAsync(m_teamNumber);


            bool success = await m_monoFile.UnzipMonoFileAsync().ConfigureAwait(false);

            if (!success)
            {
                return;
            }

            //Successfully extracted files.

            await writer.WriteLineAsync("Waiting for Connection to Finish").ConfigureAwait(false);

            using (var roboRioConnection = await rioConnectionTask.ConfigureAwait(false))
            {
                if (roboRioConnection.Connected)
                {
                    await writer.WriteLineAsync("Successfully Connected to RoboRIO").ConfigureAwait(false);

                    List <string> deployFiles = m_monoFile.GetUnzippedFileList();

                    await writer.WriteLineAsync("Creating Opkg Directory").ConfigureAwait(false);

                    await
                    roboRioConnection.RunCommandAsync($"mkdir -p {DeployProperties.RoboRioOpgkLocation}",
                                                      ConnectionUser.Admin).ConfigureAwait(false);

                    await writer.WriteLineAsync("Deploying Mono Files").ConfigureAwait(false);

                    success =
                        await
                        roboRioConnection.DeployFiles(deployFiles, DeployProperties.RoboRioOpgkLocation,
                                                      ConnectionUser.Admin).ConfigureAwait(false);

                    if (!success)
                    {
                        return;
                    }

                    await writer.WriteLineAsync("Installing Mono").ConfigureAwait(false);

                    var monoRet =
                        await
                        roboRioConnection.RunCommandAsync(DeployProperties.OpkgInstallCommand, ConnectionUser.Admin)
                        .ConfigureAwait(false);

                    //Check for success.
                    bool monoSuccess = await CheckMonoInstallAsync(roboRioConnection).ConfigureAwait(false);

                    if (monoSuccess)
                    {
                        await writer.WriteLineAsync("Mono Installed Successfully").ConfigureAwait(false);
                    }
                    else
                    {
                        await
                        writer.WriteLineAsync("Mono not installed successfully. Please try again.")
                        .ConfigureAwait(false);
                    }

                    await writer.WriteLineAsync("Cleaning up installation").ConfigureAwait(false);

                    // Set allow realtime on Mono instance
                    await
                    roboRioConnection.RunCommandAsync("setcap cap_sys_nice=pe /usr/bin/mono-sgen",
                                                      ConnectionUser.Admin).ConfigureAwait(false);

                    //Removing ipk files from the RoboRIO
                    await
                    roboRioConnection.RunCommandAsync($"rm -rf {DeployProperties.RoboRioOpgkLocation}",
                                                      ConnectionUser.Admin).ConfigureAwait(false);

                    await writer.WriteLineAsync("Done. You may now deploy code to your robot.").ConfigureAwait(false);
                }
                else
                {
                    //Did not successfully connect
                    await writer.WriteLineAsync("Failed to Connect to RoboRIO. Exiting.").ConfigureAwait(false);
                }
            }
        }
コード例 #3
0
ファイル: KillButton.cs プロジェクト: moesoha/FRC-Extension
        protected override async Task ButtonCallbackAsync(object sender, EventArgs e)
        {
            await ThreadHelperExtensions.SwitchToUiThread();

            var menuCommand = sender as OleMenuCommand;

            if (menuCommand == null)
            {
                return;
            }
            if (!m_killing)
            {
                try
                {
                    string teamNumber = await Package.GetTeamNumberAsync().ConfigureAwait(true);

                    if (teamNumber == null)
                    {
                        return;
                    }

                    var writer = OutputWriter.Instance;

                    menuCommand.Visible = false;
                    m_killing           = true;

                    //Connect to RoboRIO
                    await writer.WriteLineAsync("Attempting to Connect to RoboRIO").ConfigureAwait(false);

                    using (var rioConn = await RoboRioConnection.StartConnectionTaskAsync(teamNumber).ConfigureAwait(false))
                    {
                        if (rioConn.Connected)
                        {
                            //Connected
                            await
                            writer.WriteLineAsync("Killing currently running robot code.").ConfigureAwait(false);

                            await
                            rioConn.RunCommandAsync(DeployProperties.KillOnlyCommand,
                                                    ConnectionUser.LvUser).ConfigureAwait(false);

                            await writer.WriteLineAsync("Done.").ConfigureAwait(false);

                            await ThreadHelperExtensions.SwitchToUiThread();

                            m_killing           = false;
                            menuCommand.Visible = true;
                        }
                        else
                        {
                            //Timedout
                            await writer.WriteLineAsync("RoboRIO connection timedout. Exiting.").ConfigureAwait(false);

                            await ThreadHelperExtensions.SwitchToUiThread();

                            m_killing           = false;
                            menuCommand.Visible = true;
                        }
                    }
                }
                catch (Exception ex)
                {
                    await Output.WriteLineAsync(ex.ToString()).ConfigureAwait(false);

                    await ThreadHelperExtensions.SwitchToUiThread();

                    m_killing           = false;
                    menuCommand.Visible = true;
                    await OutputWriter.Instance.WriteLineAsync("Code Kill Failed").ConfigureAwait(false);
                }
            }
        }