susi-qemu 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1dea990fdc410fb49ca174ec0a224c6a9561b557c334d8878ce09e044bafe810
+  data.tar.gz: 65fc4f31010e7a2da46e68bb1b9704c6a44209ab993e167e850322c317a15799
+SHA512:
+  metadata.gz: 91b8c72497b3b8c88cb8508bcb409d65850f0c489507c0f4e3f74c0a25da40cb0a23fc1928f408fbbb63fa25787e878474269f8d9942299f5b43a63d794d2523
+  data.tar.gz: 6d9d80553774e38b5a812c7c58f04d120b62f12e3a06ad5a150b53d5003a59466e0883948f61ff9028a3ed12ec1faec07ec3e603810681e3ca3a39b9698c3f18

data/bin/susi

@@ -0,0 +1,128 @@
+#!/usr/bin/env ruby
+
+require 'susi'
+
+if ARGV[0] == 'init'
+  Susi::init
+
+elsif ARGV[0] == 'start'
+  Susi::start
+
+elsif ARGV[0] == 'rm'
+  # quit vm and remove disk
+  Susi::VM.quit(Susi::current_vm_name)
+  Susi::rm
+
+# create a disk
+elsif ARGV[0] == 'disk' && ARGV[1] == 'create' &&
+    ARGV[2].is_a?(String) && ARGV[3].to_i > 0
+  disk_name = ARGV[2]
+  disk_size = ARGV[3].to_i
+  Susi::Disk.create(disk_name, disk_size)
+
+# clone a disk
+elsif ARGV[0] == 'disk' && ARGV[1] == 'clone' &&
+    ARGV[2].is_a?(String) && ARGV[3].is_a?(String) &&
+    File.exist?("#{ARGV[2]}.qcow2") &&
+    !File.exist?("#{ARGV[3]}.qcow2")
+  disk_name = ARGV[2]
+  new_disk_name = ARGV[3]
+  Susi::Disk.clone(disk_name, new_disk_name)
+
+# start VM
+elsif ARGV[0] == 'vm' && ARGV[1] == 'start' &&
+    ARGV[2].is_a?(String) && File.exist?("#{ARGV[2]}.qcow2")
+  vm_name = ARGV[2]
+  Susi::VM.start(vm_name, vm_name)
+
+# install VM
+elsif ARGV[0] == 'vm' && ARGV[1] == 'install' &&
+  ARGV[2].is_a?(String) && File.exist?("#{ARGV[2]}.qcow2") &&
+    ARGV[3].is_a?(String) && File.exist?(ARGV[3])
+  vm_name = ARGV[2]
+  iso = ARGV[3]
+  Susi::VM.install(vm_name, vm_name, iso)
+
+# quit VM
+elsif ARGV[0] == 'vm' && ARGV[1] == 'quit' &&
+    ARGV[2].is_a?(String)
+  vm_name = ARGV[2]
+  Susi::VM.quit(vm_name)
+
+# list VMs
+elsif ARGV[0] == 'vm' && ARGV[1] == 'ls'
+  Susi::VM.ls
+elsif ARGV[0] == 'ls'
+  Susi::VM.ls
+
+# open VNC
+elsif ARGV[0] == 'vnc' &&
+    ARGV[1].is_a?(String)
+  vm_name = ARGV[2]
+  Susi::VNC.open(vm_name)
+
+# open SSH
+elsif ARGV[0] == 'ssh'
+  if ARGV[1].is_a?(String)
+    vm_name = ARGV[1]
+    Susi::SSH.open(vm_name)
+  else
+    Susi::SSH.open(Susi::current_vm_name)
+  end
+
+# download Debian netinstall ISO
+elsif ARGV[0] == 'iso' && ARGV[1] == 'download'
+  Susi::Disk.download_debian_netinstall
+
+else
+  puts <<-EOF
+Invalid command
+
+Usage: 
+  Init susi setting
+  susi init
+
+  Start VM from current folder 
+  susi start
+
+  Clean up disks
+  susi rm
+
+  Create a VM disk
+  susi disk create <disk_name> <disk_size>
+
+  Clone a VM disk
+  susi disk clone <disk_name> <new_disk_name>
+
+  Start a VM
+  susi vm start <vm_name>
+
+  Install a VM
+  susi vm install <vm_name> <iso>
+
+  Quit a VM
+  susi vm quit <vm_name>
+
+  List VMs
+  susi ls
+  susi vm ls
+
+  Open VNC
+  susi vnc <vm_name>
+
+  Open SSH
+  susi ssh <vm_name>
+
+  Download Debian netinstall ISO
+  susi iso download
+
+susi (v#{Susi::VERSION}) - Simple User System Interface
+
+author:  Daniel Bovensiepen
+contact: oss@bovi.li
+www:     https://github.com/bovi/susi
+EOF
+
+exit 1
+
+end

data/lib/disk.rb

@@ -0,0 +1,45 @@
+module Susi
+  class Disk
+    DEFAULT_IMG = "debian-12.7.0-amd64-netinst.iso"
+
+    def self.download_debian_netinstall
+      # Check if ~/.susi directory exists, if not create it
+      susi_dir = File.expand_path("~/.susi")
+      Dir.mkdir(susi_dir) unless Dir.exist?(susi_dir)
+
+      # Check if ~/.susi/iso directory exists, if not create it
+      iso_dir = File.join(susi_dir, "iso")
+      Dir.mkdir(iso_dir) unless Dir.exist?(iso_dir)
+
+      # Set the output path to be in the iso directory
+      output_path = File.join(iso_dir, DEFAULT_IMG)
+
+      url = "https://mirrors.tuna.tsinghua.edu.cn/debian-cd/current/amd64/iso-cd/#{DEFAULT_IMG}"
+      
+      puts "Downloading Debian netinstall ISO..."
+      
+      begin
+        URI.open(url) do |remote_file|
+          File.open(output_path, "wb") do |local_file|
+            local_file.write(remote_file.read)
+          end
+        end
+        puts "Download completed successfully."
+      rescue OpenURI::HTTPError => e
+        puts "Error downloading the ISO: #{e.message}"
+      rescue SocketError => e
+        puts "Network error: #{e.message}"
+      rescue => e
+        puts "An unexpected error occurred: #{e.message}"
+      end
+    end
+
+    def self.create(name, size)
+      system("qemu-img create -f qcow2 #{name}.qcow2 #{size}G > /dev/null 2>&1")
+    end
+
+    def self.clone(name, clone)
+      system("qemu-img create -f qcow2 -F qcow2 -b #{name}.qcow2 #{clone}.qcow2 > /dev/null 2>&1")
+    end
+  end
+end

data/lib/qmp.rb

@@ -0,0 +1,56 @@
+require 'socket'
+require 'json'
+
+module Susi
+  class QMP
+    def initialize(port)
+      @port = port
+      @server = TCPSocket.new('localhost', @port)
+
+      resp = JSON.parse(@server.gets)
+      unless resp["QMP"]["version"]["qemu"]["major"] == 9
+        server.close
+        raise "QEMU version not supported"
+      end
+
+      # handshake to initialize QMP
+      @server.puts('{"execute":"qmp_capabilities"}')
+      resp = JSON.parse(@server.gets)
+      unless resp["return"] == {}
+        server.close
+        raise "Failed to connect to QMP socket"
+      end
+
+      if block_given?
+        yield(self)
+        self.close
+      end
+    end
+
+    def execute(cmd)
+      @server.puts(JSON.dump({"execute" => cmd}))
+      resp = JSON.parse(@server.gets)
+      resp["return"]
+    end
+
+    def execute_with_args(cmd, args)
+      @server.puts(JSON.dump({"execute" => cmd, "arguments" => args}))
+      resp = JSON.parse(@server.gets)
+      resp["return"]
+    end
+
+    def name
+      @server.puts('{"execute":"query-name"}')
+      resp = JSON.parse(@server.gets)
+      resp["return"]["name"]
+    end
+
+    def quit
+      @server.puts('{"execute":"quit"}')
+    end
+
+    def close
+      @server.close
+    end
+  end
+end

data/lib/ssh.rb

@@ -0,0 +1,19 @@
+require 'socket'
+require 'net/ssh'
+
+module Susi
+  class SSH
+    def self.open(name)
+      vm = VM.new(name)
+      exec "ssh -p #{vm.ssh_port} dabo@#{vm.ip}"
+    end
+
+    def self.set_hostname(name)
+      vm = VM.new(name)
+      Net::SSH.start(vm.ip, 'dabo', port: vm.ssh_port, keys: [File.expand_path('~/.ssh/id_ed25519')]) do |ssh|
+        puts "setting up VM..."
+        ssh.exec!("sudo hostnamectl set-hostname #{name}")
+      end
+    end
+  end
+end

data/lib/susi.rb

@@ -0,0 +1,164 @@
+#!/usr/bin/env ruby
+
+require_relative 'qmp'
+require_relative 'vm'
+require_relative 'ssh'
+require_relative 'vnc'
+require_relative 'disk'
+
+require 'yaml'
+require 'securerandom'
+
+module Susi
+  VERSION = '0.0.1'
+  CONFIG_FILE = ".susi.yml"
+  SUSI_DIR = "#{ENV['HOME']}/.susi"
+  TEMPLATE_DIR = "#{SUSI_DIR}/templates"
+  DISK_DIR = "#{SUSI_DIR}/disks"
+
+  def self.current_vm_name
+    if !File.exist?(CONFIG_FILE)
+      raise "susi is not initialized"
+    end
+
+    # load config
+    config = YAML.load_file(CONFIG_FILE)
+    config['name'] || Dir.pwd.split('/').last
+  end
+
+  def self.init
+    # check if .susi.yml exist, if not create it
+    if !File.exist?(CONFIG_FILE)
+      # create unique ID
+      id = SecureRandom.uuid
+
+      File.open(CONFIG_FILE, "w") do |file|
+        file.puts <<-YAML
+id: #{id}
+template: DEFAULT
+YAML
+      end
+    end
+  end
+
+  def self.start
+    if !File.exist?(CONFIG_FILE)
+      raise "susi is not initialized"
+    end
+
+    # load config
+    config = YAML.load_file(CONFIG_FILE)
+    id = config['id']
+    name = config['name'] || Dir.pwd.split('/').last
+    disk_template = "#{TEMPLATE_DIR}/#{config['template']}"
+
+    # check if vm is already running
+    if VM.running?(name)
+      raise "VM #{name} is already running"
+    end
+
+    # check if disk exist, if not clone it
+    disk_name = "#{DISK_DIR}/#{id}"
+    if !File.exist?("#{disk_name}.qcow2")
+      puts "Disk not found, cloning..."
+      Susi::Disk.clone(disk_template, disk_name)
+
+      Susi::VM.start(name, disk_name)
+
+      # SSH into VM and set hostname
+      Susi::SSH.set_hostname(name)
+    else
+      Susi::VM.start(name, disk_name)
+    end
+  end
+
+  def self.rm
+    if !File.exist?(CONFIG_FILE)
+      raise "susi is not initialized"
+    end
+
+    # load config
+    config = YAML.load_file(CONFIG_FILE)
+    id = config['id']
+    disk_name = "#{DISK_DIR}/#{id}.qcow2"
+
+    if File.exist?(disk_name)
+      # verbose remove file
+      puts "removing #{disk_name}"
+      File.delete(disk_name)
+    end
+  end
+end
+
+# perform a test when the script is run
+if __FILE__ == $0
+  require 'test/unit'
+
+  class SusiTest < Test::Unit::TestCase
+    def run_command(cmd)
+      system("#{cmd} > /dev/null 2>&1")
+    end
+
+    def test_cli_empty
+      assert_equal(false, run_command("ruby ./susi.rb"))
+    end
+
+    def test_create_img
+      Susi::Disk.create("test", "1")
+
+      # check created file
+      assert(File.exist?("test.qcow2"))
+      info = `qemu-img info test.qcow2`
+      assert(info.include?("virtual size: 1 GiB"))
+      assert(info.include?("format: qcow2"))
+
+      run_command("rm test.qcow2")
+    end
+
+    def test_cli_create_img
+      assert_equal(true, run_command("ruby ./susi.rb disk create test 1"))
+      assert(File.exist?("test.qcow2"))
+      run_command("rm test.qcow2")
+    end
+
+    def test_cli_create_img_fail
+      assert_equal(false, run_command("ruby ./susi.rb disk create test"))
+      assert_equal(false, run_command("ruby ./susi.rb disk create test pest"))
+      assert_equal(false, run_command("ruby ./susi.rb disk create 1"))
+    end
+
+    def test_clone_img
+      Susi::Disk.create("test", "1")
+      Susi::Disk.clone("test", "clone")
+
+      assert(File.exist?("clone.qcow2"))
+      info = `qemu-img info clone.qcow2`
+      assert(info.include?("virtual size: 1 GiB"))
+      assert(info.include?("format: qcow2"))
+      assert(info.include?("backing file: test.qcow2"))
+      assert(info.include?("backing file format: qcow2"))
+
+      run_command("rm clone.qcow2")
+      run_command("rm test.qcow2")
+    end
+
+    def test_cli_clone_img
+      assert_equal(true, run_command("ruby ./susi.rb disk create test 1"))
+      assert_equal(true, run_command("ruby ./susi.rb disk clone test clone"))
+      assert(File.exist?("clone.qcow2"))
+      run_command("rm clone.qcow2")
+      run_command("rm test.qcow2")
+    end
+
+    def test_cli_clone_img_fail
+      assert_equal(false, run_command("ruby ./susi.rb disk clone test clone"))
+      assert_equal(true, run_command("ruby ./susi.rb disk create test 1"))
+      assert_equal(false, run_command("ruby ./susi.rb disk clone test"))
+      assert_equal(true, run_command("ruby ./susi.rb disk clone test clone"))
+      assert_equal(false, run_command("ruby ./susi.rb disk clone test clone"))
+
+      run_command("rm clone.qcow2")
+      run_command("rm test.qcow2")
+    end
+  end
+end

data/lib/vm.rb

@@ -0,0 +1,171 @@
+module Susi
+  class VM
+    def self.running?(name)
+      ps = `ps aux | grep qemu-system-x86_64`
+      ps.split("\n").each do |line|
+        next unless line.match /\-name/
+        m = line.match(/-name (\w+)/)
+        n = m[1]
+        return true if n == name
+      end
+      return false
+    end
+
+    def initialize(name)
+      @name = name
+      @qmp_port = nil
+      @vnc_port = nil
+      @ssh_port = nil
+
+      ps = `ps aux | grep qemu-system-x86_64`
+      ps.split("\n").each do |line|
+        next unless line.match /\-name/
+        m = line.match(/-name (\w+)/)
+        n = m[1]
+        next unless n == @name
+
+        m = line.match(/-qmp tcp:localhost:(\d+)/)
+        @qmp_port = m[1].to_i
+      end
+    end
+
+    def quit
+      QMP.new(@qmp_port) { |q| q.quit }
+    end
+
+    def disk
+      d = ''
+      QMP.new(@qmp_port) { |q| d = q.execute("query-block")[0]['inserted']['file'] }
+      d
+    end
+
+    def vnc_port
+      @vnc_port ||= begin
+        port = -1
+        QMP.new(@qmp_port) { |q| port = q.execute("query-vnc")['service'] }
+        port.to_i
+      end
+    end
+
+    def vnc_www_port
+      vnc_port - 5900 + 5800
+    end
+
+    def vnc_websocket_port
+      vnc_port - 5900 + 5700
+    end
+
+    def ssh_port
+      @ssh_port ||= begin
+        port = -1
+        QMP.new(@qmp_port) do |q|
+          resp = q.execute_with_args("human-monitor-command", {"command-line" => "info usernet"})
+          resp = resp.split("\r\n")[2].split
+          src_port = resp[3].to_i
+          dst_port = resp[5].to_i
+          if dst_port == 22
+            port = src_port
+          end
+        end
+        port.to_i
+      end
+    end
+
+    def ip
+      ip = Socket.ip_address_list.find { |ai| ai.ipv4? && !ai.ipv4_loopback? }
+      ip.ip_address
+    end
+
+    def qmp_port
+      @qmp_port
+    end
+
+    def self.quit(name)
+      vm = VM.new(name)
+      vm.quit
+    end
+
+    def self.install(name, disk, iso)
+      self.start(name, disk, cdrom: iso)
+    end
+
+    def self.get_free_port(start_port, end_port)
+      (start_port..end_port).each do |port|
+        begin
+          server = TCPServer.new('127.0.0.1', port)
+          server.close
+          return port
+        rescue Errno::EADDRINUSE
+          next
+        end
+      end
+      raise "No free port found in range #{start_port}..#{end_port}"
+    end
+
+    def self.start(name, disk, cdrom: nil)
+      qmp_port = self.get_free_port(4000, 4099)
+      ssh_port = self.get_free_port(2000, 2099)
+      vnc_port = self.get_free_port(5900, 5999)
+      vnc_www_port = 5800 + vnc_port - 5900
+      vnc_websocket_port = 5700 + vnc_port - 5900
+
+      puts "QMP Port: #{qmp_port}"
+      puts "SSH Port: #{ssh_port}"
+      puts "VNC Port: #{vnc_port}"
+      puts "VNC WWW Port: #{vnc_www_port}"
+      puts "VNC WebSocket Port: #{vnc_websocket_port}"
+
+      cmd = []
+
+      cmd << "~/susi/docs/qemu/build/qemu-system-x86_64"
+
+      # general setup
+      cmd << "-name #{name}"
+      cmd << "-m 2048"
+      cmd << "-hda #{disk}.qcow2"
+      cmd << "-daemonize"
+      cmd << "-enable-kvm"
+
+      # control interfaces
+      cmd << "-qmp tcp:localhost:#{qmp_port},server,nowait"
+      cmd << "-vnc :#{vnc_port-5900},websocket=on"
+
+      # Network capabilities
+      cmd << "-nic user,model=virtio-net-pci,hostfwd=tcp::#{ssh_port}-:22"
+
+      # cdrom for installation
+      if cdrom
+        cmd << "-cdrom #{cdrom}"
+      end
+
+      puts cmd.join(" ")
+      system(cmd.join(" "))
+
+      QMP.new(qmp_port).close
+    end
+
+    def self.ls
+      ps = `ps aux | grep qemu-system-x86_64`
+      ps.split("\n").each do |line|
+        next unless line.match /\-name/
+
+        # get VM access
+        m = line.match(/-name (\w+)/)
+        n = m[1]
+        vm = VM.new(n)
+
+        # get local device name or IP
+        ip = Socket.ip_address_list.find { |ai| ai.ipv4? && !ai.ipv4_loopback? }
+
+        puts <<-EOF
+VM: #{n}
+  - Disk: #{vm.disk}
+  - QMP: #{vm.qmp_port}
+  - VNC: vnc://#{ip.ip_address}:#{vm.vnc_port}
+  - Screen: http://#{ip.ip_address}:#{vm.vnc_www_port}/
+  - SSH: ssh -p #{vm.ssh_port} dabo@#{ip.ip_address}
+EOF
+      end
+    end
+  end
+end

data/lib/vnc.rb

@@ -0,0 +1,46 @@
+require 'socket'
+require 'webrick'
+
+module Susi
+  class VNC
+    def self.open(name)
+      vm = VM.new(name)
+      port = vm.vnc_www_port
+      ip = Socket.ip_address_list.find { |ai| ai.ipv4? && !ai.ipv4_loopback? }
+      token = (0...8).map { (65 + rand(26)).chr }.join
+      url = "http://#{ip.ip_address}:#{port}/#{token}.html"
+
+      # prepare paths and files
+      path = File.expand_path(File.dirname(__FILE__))
+      novnc_path = File.join(path, "novnc")
+      html = File.read(File.join(novnc_path, "screen.html"))
+      html.gsub!("###TOKEN###", token)
+      html.gsub!("###HOST###", ip.ip_address)
+      html.gsub!("###PORT###", vm.vnc_websocket_port.to_s)
+
+      server = WEBrick::HTTPServer.new(:Port => port,
+                                       :Logger => WEBrick::Log.new("/dev/null"),
+                                       :AccessLog => [])
+      server.mount_proc "/#{token}.html" do |req, res|
+        # print access by someone on command line
+        puts "[#{Time.now}] Access by: #{req.peeraddr[3]}"
+        res.body = html
+      end
+      server.mount_proc "/#{token}.close.html" do |req, res|
+        puts "[#{Time.now}] Closing VNC..."
+        res.body = "Closing VNC..."
+        server.shutdown
+      end
+      server.mount("/core",
+                   WEBrick::HTTPServlet::FileHandler,
+                   File.join(novnc_path, "core"))
+      server.mount("/vendor",
+                   WEBrick::HTTPServlet::FileHandler,
+                   File.join(novnc_path, "vendor"))
+
+      puts "[#{Time.now}] VNC screen: #{url}"
+
+      server.start
+    end
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: susi-qemu
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Daniel Bovensiepen
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-09-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.2.0
+description: Config, manage, and maintain multiple QEMU instances for your projects
+email: oss@bovi.li
+executables:
+- susi
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/susi
+- lib/disk.rb
+- lib/qmp.rb
+- lib/ssh.rb
+- lib/susi.rb
+- lib/vm.rb
+- lib/vnc.rb
+homepage: https://github.com/bovi/susi
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/bovi/susi
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.15
+signing_key:
+specification_version: 4
+summary: Manage project QEMU instances
+test_files: []