Hasker's SE 3800 & Unix

[Pull up Ubuntu Linux with Terminal Window open]

• Running unix within VirtualBox
• Virtual machines:
  • emulates the full computer system
  • separate file system, address spaces, process queues, etc.
  • can "link" files in the virtual machine to files on the host, so changes to the VM files will be visible on the host
  • also typically share network connection
  • however, operations generally do not affect the host machine other than to take CPU cycles
• This would allow running (say) Windows95 on a Windows10 box
• "Virtual" because ultimately there's no new hardware, just making the hardware look like multiple machines are running at the same time...

Why Unix?

• Linux: a variant of the Unix operating system
• Parallel paths in SE 3800: theory (reducing risk) + practice (automated testing); will use Linux/Unix in several courses
• Unix: robust, well-tested, powerful framework, powerful toolset
• Can't afford Windows for every AWS image
• Windows not designed to be a server from ground up
• Unix: almost everything is a file, making it easy to do things like swap out configurations & databases

Directory Structure

• Top level: /, /usr, /bin, /home
  • files, folders: case-sensitive
  • Windows: allows mixing, which can be confusing, and not all tools have the same behavior
• Changing directories: cd
  • Windows term: folders
• ls /bin and note commands
• /tmp: temporary files
• permissions: see /etc: ls -l /etc | more
  • rw: read, write access
  • owner, group, world (all users)
  • x: execute; "entry" permission for directories
• ls -la ~
• ls -la /root
• sudo ls -la /root
  • sudo: run as super user
  • avoid! Use only if you know the command won't complete otherwise
  • Times it's needed: installing software, starting services
• cd; cat .bashrc
• more .bashrc
• man
• Bash; man bash
  • bash, cd /
  • exit
  • pwd
• cp .bashrc start; ls
• rm start; ls
• $PATH - how to find a command
  • note /bin early, type /bin/ls
  • . - current directory
  • Note current directory not in $path - keeps someone from having an executable named ls that people execute by mistake
  • Windows version: PATH (often written as %PATH%)

How Programs Are Run

• execution environment
  • variables: settings used
    • columns, username, options

      $ echo $COLUMNS
      $ echo $USER
      

    • Known as the environment
  • Arguments: text from the command line
    • Available in both Unix and Windows
    • Universal separator: space
    • Windows command

      C:\> copy c:\Users\Public\ntuser.dat .
      

      • C:> - prompt; has current directory
      • copy - command to execute
      • c:\Users\Public\ntuser.dat - first argument
      • . - second argument
      • Use " marks if have spaces in names - a pain
  • Execution environment
    • Windows: registry
    • Unix command files: #!command
    • Eg: Ruby args program
    • In C, C++: int argc, char **argv, char **envp
      • See occurrences.cpp
      • grabs one character from first arg and searches input for that character
• Unix shell such as GNU bash:
  • Maintains list of environment variables
  • When run a command (in brief),
    1. take snapshot of environment
    2. glob the command line arguments: expand (say) *.o into a list of filenames ending in .o
    3. Find location of command using $PATH
    4. Determine what executable to start
    5. Run the executable in its own memory space, passing argc, argv, envp

Docker

• Unix: written at AT&T in late 60's, early 70's, $3000-$5000 for license on small machines
• Linux: open source version first released in 1991 (Linus Torvalds)
• Initially: Unix/Linux machines would have dozens or even hundreds of users
  • Shared resource, many services
  • As hardware dropped in price, dedicated servers became more common
  • Issue: managing many servers gets time-consuming
  • Also: few servers fully utilize a computer's resources, so lots of wasted CPU cycles
• Virtual machine: emulating a full computer on another computer
  • VirtualBox: Oracle's system to run other operating systems on your computer
    • Can spin up virtual environments for Windows 10, various flavors of Linux
    • For Windows licenses (as a student), see Microsoft Imagine
    • Mac OS X: only legal to run on a Mac
  • Can create snapshots of VMs so can save and restore states during debugging, etc.
• Docker:
  • Checking docker runs:

            docker run hello-world
    

  • Docker as a virtual machine server:

    $ docker run -it ubuntu:18.04
    

  • Core unit: a container
  • Structure: containerized applications
  • Layered: each container built on the one below it
    • Topmost layer is writeable
    • Allows sharing between layers
    • In contrast, the virtual machine model in which each machine has its own copy of the operating system
  • Dockerfile: container configuration
    • Dockerfile
    • Each RUN: creates a new container based on the one before it
    • Containers are cached so do not have to reload each until there's a change
  • Note: using VirtualBox to run Ubuntu Linux for convenience
    • Docker requires Hyper-V on windows
    • VirtualBox requires virtualization and Hyper-V must be off
    • Since VirtualBox is required for other courses, we just run Docker from within a standard Linux VM
    • In production, would run Docker natively on your machine
  • Docker goals
    • consistent environment for tests, production
    • Can use for development, but likely not ideal
      • Even if works for development, development tools on the production server likely creates security holes
    • Relatively easy integration with automated testing environments
    • Easy deployment on cloud-based servers
  • Assignment 1:
    • Get Virtualization turned on (if needed)
    • Install Docker, g++, GoogleTest
      • GoogleTest: a C++-based framework for writing and running tests similar to JUnit.
      • It's installation assumes you have experience with installing software on Unix; Docker takes care of this
      • Installing it on your Ubuntu VM is straightforward (modulo the experience thing)
    • Experience writing your own GoogleTest suite and integrating into Docker