Compilers: Clang/LLVM, Go, Rust

In this step, you will configure and “register” your system to obtain software from the devtools repository by using the command line interface. 

Note: registering a subscription (the steps to follow) is different than registering for the Red Hat Developer Program (which you’ve likely done by now).

You can add or remove software repositories from the command line using the subscription-manager tool as the root user. Use the --list option to view the available software repositories and verify that you have access to the devtools repo.

$ su -
# subscription-manager repos --list | egrep devtools

If you don’t see any devtools repositories in the list, your subscription might not include it. See Troubleshooting and FAQ for more information.

If you are using a desktop edition of Red Hat Enterprise Linux, change -server- to -desktop- in the following commands:

# subscription-manager repos --enable rhel-7-server-devtools-rpms
# subscription-manager repos --enable rhel-server-rhscl-7-rpms

Add the Red Hat Developer Tools key to your system:

# cd /etc/pki/rpm-gpg
# wget -O RPM-GPG-KEY-redhat-devel https://www.redhat.com/security/data/a5787476.txt
# rpm --import RPM-GPG-KEY-redhat-devel

In this next step you will use a single command to download and install the Go Compiler toolchain from the Red Hat repository. The length of time this step takes depends on the speed of your Internet connection and your system. With a reasonably fast connection, this step should complete in well under 5 minutes.

1. To install all components that are included in Go Toolset, install the go-toolset-7 package:

# yum install go-toolset-7

This installs all development and debugging tools, and other dependent packages to the system.

2. Create the Go language workspace directory and environment variable:

$ mkdir -p workspace_dir 
$ echo 'export GOPATH=workspace_dir' >> $HOME/.bashrc 
$ source $HOME/.bashrc 

Select an appropriate value for the workspace_dir directory. A common choice is $HOME/go.

If the GOPATH variable is not set, the go compiler uses the ~/go directory.

To compile a Go program on the command line, run the go compiler as follows:
 

# scl enable go-toolset-7 'go build -o output_file go_main_package’

This creates a binary file named output_file in the current working directory. If the -o option is omitted, the compiler creates a file named after the go_main_package, "go_main_package". If go_main_package is not main package or if multiple projects or *.go files are specified resulting binaries are discarded. In this use go build work as verification that the supplied projects/files are buildable.

Note that you can execute any command using the scl utility, causing it to be run with the Go Toolset binaries. This allows you to run a shell session with Go Toolset as default:
 

scl enable go-toolset-7 'bash'

Using the Go Compiler

Example: Compiling a Go Program on the Command Line

Consider a source file named hello.go with the following contents:

       package main

       import (
           "fmt"
           "net/http"
       )

       func Welcome(w http.ResponseWriter, req *http.Request) {

           fmt.Fprintf(w, "<h1>Welcome to the Go toolset.</h1>")

       }

       func main() {

           fmt.Println("Hello.")
           fmt.Println("Starting http server.")
           // Register handler function
           http.HandleFunc("/welcome", Welcome)
           fmt.Println("Go to localhost:8080/welcome To terminate press CTRL+C")
           // Start server
            http.ListenAndServe(":8080", nil)

       }

   To compile this source code on the command line by using the Go compiler from Red Hat Go Developer Toolset, type:

$ scl enable go-toolset-7 'go build hello.go'

 This creates a new binary file called hello in the current working directory.

 Running a C Program

When Go compiler compiles a program, it creates an executable binary file. To run this program on the command line, change to the directory with the executable file and type:

  ./file_name

Example: Running a C Program on the Command Line

Assuming that you have successfully compiled the hello binary file as shown in previous Example, “Compiling a Go Program on the Command Line”, you can run it by typing the following at a shell prompt:

   ./hello
   Hello.
   Starting http server.
   Go to localhost:8080/welcome To terminate press CTRL+C

In this step, you will configure and “register” your system to obtain software from the devtools repository by using the command line interface. 

Note: registering a subscription (the steps to follow) is different than registering for the Red Hat Developer Program (which you’ve likely done by now).

You can add or remove software repositories from the command line using the subscription-manager tool as the root user. Use the --list option to view the available software repositories and verify that you have access to the devtools repo.

$ su -
# subscription-manager repos --list | egrep devtools

If you don’t see any devtools repositories in the list, your subscription might not include it. See Troubleshooting and FAQ for more information.

If you are using a desktop edition of Red Hat Enterprise Linux, change -server- to -desktop- in the following commands:

# subscription-manager repos --enable rhel-7-server-devtools-rpms
# subscription-manager repos --enable rhel-server-rhscl-7-rpms

Add the Red Hat Developer Tools key to your system:

# cd /etc/pki/rpm-gpg
# wget -O RPM-GPG-KEY-redhat-devel https://www.redhat.com/security/data/a5787476.txt
# rpm --import RPM-GPG-KEY-redhat-devel

In this next step you will use a single command to download the Rust compiler. The length of time this step takes depends on the speed of your Internet connection and your system. With a reasonably fast connection, this step should complete in well under 5 minutes.

$ su -
# yum install rust-toolset-7

In Rust Toolset, cargo is provided by the rust-toolset-7-cargo package and is automatically installed with the rust-toolset-7 package.

Create and run the sample C++ Hello World projects

The following steps will create and run a Rust Hello World project

Using Rust from the command line

The Rust compiler (rustc) is not usually invoked directly, but through the cargo tool, like cargo build. You need to add Rust to your environment with scl enable in a Terminal window.

$ scl enable rust-toolset-7 bash

The simplest way to get started with a new project is using cargo new.  Create a hello executable project using “cargo new --bin hello”.  This will create a new directory with a Cargo.toml project manifest and the src/main.rs entry point for your program.

hello/Cargo.toml
   [package]
   name = "hello"
   version = "0.1.0"
   authors = ["I.M Coder <imc@redhat.com>"]

   [dependencies]

hello/src/main.rs
   fn main() {
       println!("Hello, world!");
   }

Now compile and run the program:

$ cd hello
$ cargo run
Hello, world!

Let’s customize that message.  Edit src/main.rs using a text editor such as vi, nano, or gedit, changing to the following content:

fn main() {
">println!("Hello, Red Hat Developer Program World!");
}

When making changes it’s often useful to get quick feedback from the compiler that your code will be accepted.  You can run cargo check for full syntax and type checking, without the longer delays for code generation.  Then when you’re ready, compile and run it again.

$ cargo run
Hello, Red Hat Developer Program World!