cangallo 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a5714dca973ec1755fc348bbef4494c7e1da8c41
+  data.tar.gz: 4abacf5c9616cb358befa15117d1682b26236a1b
+SHA512:
+  metadata.gz: f817d57b34e4758aa33886d34ca0e9d744385a47c497ca33764ffcf988658f2172085ca2f25c3f778a09e8ee74b74844571b86d65e0b4bc4f7e5c1e17fa3eaf4
+  data.tar.gz: d2877b68c3ed720db1163dcb0c352a0d97fefcff866501d5f54375f223b1b57f02f08b5acafea0f59a907f16f447ac67d6bb623f6aaf427c2d7db62c05031b6a

data/bin/canga

@@ -0,0 +1,307 @@
+#!/usr/bin/env ruby
+
+# vim:ts=2:sw=2
+
+# Copyright 2016, Javier Fontán Muiños <jfontan@gmail.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+$: << File.dirname(__FILE__) + "/../lib"
+
+require "rubygems"
+require "thor"
+require "fileutils"
+require "digest"
+require "cangallo"
+require "tempfile"
+
+require "pp"
+
+$cangallo = Cangallo.new
+
+class Canga < Thor
+  map ['--version', '-V'] => :__print_version
+
+  desc "--version, -V", "show version"
+  def __print_version
+    puts Cangallo::VERSION
+  end
+
+  desc "create FILE [SIZE]", "create a new qcow2 image"
+  option :parent, :desc => "id of the parent image"
+  def create(file, size = nil)
+    puts [file, size]
+    Cangallo::Qcow2.create(file, options[:parent], size)
+  end
+
+  desc "add FILE [REPO]", "add a new file to the repository"
+  option :parent, :desc => "id of the parent image"
+  option :tag, :desc => "tag name of the new image"
+  option :copy, :desc => "do not process the image, make an exact copy",
+          :type => :boolean
+  def add(file, repo_name = nil)
+    repo = $cangallo.repo(repo_name)
+    sha256 = repo.add_image(file, "only_copy" => options[:copy])
+
+    repo.add_tag(options[:tag], sha256) if options[:tag]
+  end
+
+  desc "del IMAGE", "delete an image from the repository"
+  def del(name)
+    image = $cangallo.get(name)
+
+    if !image
+      STDERR.puts %Q{Image "#{name}" not found}
+      exit(-1)
+    end
+
+    repo = $cangallo.repo(image["repo"])
+    repo.del_image(image["sha256"])
+  end
+
+  desc "tag TAGNAME IMAGE", "add a tag name to an existing image"
+  def tag(tag, name)
+    image = $cangallo.get(name)
+
+    if !image
+      STDERR.puts %Q{Image "#{name}" not found}
+      exit(-1)
+    end
+
+    repo = $cangallo.repo(image['repo'])
+    repo.add_tag(tag, image['sha256'])
+  end
+
+  desc "deltag TAGNAME", "delete a tag"
+  def deltag(tag)
+    repo, name = $cangallo.parse_name(tag)
+    image = $cangallo.get(tag)
+
+    if !image
+      STDERR.puts %Q{Image "#{name}" not found}
+      exit(-1)
+    end
+
+    repo = $cangallo.repo(repo)
+    repo.del_tag(name)
+  end
+
+  desc "list [REPO]", "list images"
+  def list(repo_name = nil)
+    images = $cangallo.get_images(repo_name)
+
+    format = "%-50.50s %11.11s %8.8s"
+
+    print "\e[1;4m"
+    print format % %w{NAME SIZE DAYS_AGO}
+    puts "\e[0m"
+
+    images.each do |image|
+      parent = image["parent"] ? "^" : " "
+      available = image["available"] ? " " : "*"
+      name = "#{parent}#{available}#{image["name"]}"
+
+      size = image["size"].to_f / (1024 * 1024) # Mb
+      size = size.round(1)
+
+      if image["creation-time"]
+        days = ( Time.new - image["creation-time"] ) / (60*60*24)
+        days = days.round(1)
+      else
+        days = "N/A"
+      end
+
+      print "\e[1m"
+      print format % [name, "#{size} Mb", days]
+      puts "\e[0m"
+
+      puts "    %-70.70s" % [image["description"]] if image["description"]
+    end
+  end
+
+  desc "show IMAGE", "show information about an image"
+  def show(name)
+    image = $cangallo.get(name)
+
+    if image
+      puts image.to_yaml
+    else
+      STDERR.puts "No image found with name '#{name}'"
+      exit(-1)
+    end
+  end
+
+  desc "overlay IMAGE FILE", "create a new image based on another one"
+  def overlay(name, file)
+    image = $cangallo.get(name)
+
+    if !image
+      STDERR.puts "Image not found"
+      exit(-1)
+    end
+
+    repo = $cangallo.repo(image['repo'])
+    path = File.expand_path(repo.image_path(image['sha256']))
+
+    Cangallo::Qcow2.create_from_base(path, file)
+  end
+
+  desc "build CANGAFILE", "create a new image using a Cangafile"
+  option :tag, :desc => "tag name of the new image"
+  def build(file)
+    cangafile = Cangallo::Cangafile.new(file)
+
+    commands, params = cangafile.render
+    puts commands
+
+    begin
+      image = $cangallo.get(cangafile.parent)
+    rescue => e
+      STDERR.puts e.message
+      exit(-1)
+    end
+
+    if !image
+      STDERR.puts "Image not found"
+      exit(-1)
+    end
+
+    sha256 = image['sha256']
+    repo = $cangallo.repo(image['repo'])
+
+    parent_path = File.expand_path(repo.image_path(sha256))
+
+    # temp image path
+    temp_image = Tempfile.new([File.basename(file), '.qcow2'], repo.path)
+    temp_image.close
+
+    Cangallo::Qcow2.create_from_base(parent_path, temp_image.path)
+
+    rc = Cangallo::LibGuestfs.virt_customize(temp_image.path, commands, params)
+    exit(-1) if !rc
+
+    rc = Cangallo::LibGuestfs.virt_sparsify(temp_image.path)
+    exit(-1) if !rc
+
+    data = {}
+    data["parent"] = sha256
+    data["description"] = cangafile.data["description"]
+    data["os"] = cangafile.data["os"]
+    cangafile.data.delete("description")
+    cangafile.data.delete("os")
+
+    data["cangafile"] = cangafile.data
+
+    new_image = repo.add_image(temp_image.path, data)
+
+    puts "Deleting temporary image"
+    temp_image.delete
+
+    tag = options[:tag] || cangafile.data['tag']
+
+    repo.add_tag(tag, new_image) if tag
+  end
+
+  desc "fetch [REPO]", "download the index of the repository"
+  def fetch(repo_name = nil)
+    repo = $cangallo.repo(repo_name)
+
+    repo.fetch
+  end
+
+  desc "sign [REPO]", "sign the index file with keybase"
+  def sign(repo_name = nil)
+    repo = $cangallo.repo(repo_name)
+    repo.sign
+  end
+
+  desc "verify [REPO]", "verify index signature with keybase"
+  def verify(repo_name = nil)
+    repo = $cangallo.repo(repo_name)
+    repo.verify
+  end
+
+  desc "pull NAME", "download an image from a remote repository"
+  def pull(name)
+    image = $cangallo.get(name)
+
+    if !image
+      STDERR.puts "Image not found"
+      exit(-1)
+    end
+
+    repo = $cangallo.repo(image["repo"])
+    images = repo.ancestors(image["sha256"])
+
+    images.reverse.each do |img|
+      name = $cangallo.short_name(img, image["repo"])
+      if File.exist?(repo.image_path(img))
+        STDERR.puts "Image #{name} already downloaded"
+      else
+        STDERR.puts "Downloading #{name}"
+        repo.pull(img)
+      end
+    end
+  end
+
+  desc "export IMAGE OUTPUT", "export an image to a file"
+  option :format, :desc => "format for output image", :default => :qcow2,
+         :aliases => :f
+  option :compress, :desc => "compress output qcow2 image", :default => false,
+         :aliases => :c
+  def export(image, output)
+    image = $cangallo.get(image)
+
+    if !image
+      STDERR.puts "Image not found"
+      exit(-1)
+    end
+
+    repo = $cangallo.repo(image["repo"])
+    path = File.expand_path(repo.image_path(image["sha256"]))
+
+    Cangallo::Qcow2.new(path).convert(output,options)
+  end
+
+  desc "import IMAGE [REPO]", "import an image from a remote repository"
+  option :tag, :desc => "tag name of the new image"
+  def import(image_name, repo = nil)
+    image = $cangallo.get(image_name)
+
+    if !image
+      STDERR.puts "Image not found"
+      exit(-1)
+    end
+
+    sha256 = image["sha256"]
+
+    remote_repo = $cangallo.repo(image["repo"])
+    remote_path = remote_repo.image_path(sha256)
+
+    repository = $cangallo.repo(repo)
+    image_path = repository.image_path(sha256)
+
+    FileUtils.ln(remote_path, image_path, force: true)
+
+    image.delete("repo")
+    repository.add(sha256, image)
+
+    repository.add_tag(options[:tag], sha256) if options[:tag]
+
+    repository.write_index
+  end
+end
+
+Canga.start(ARGV)
+
+

data/lib/cangallo.rb

@@ -0,0 +1,120 @@
+
+# vim:ts=2:sw=2
+
+# Copyright 2016, Javier Fontán Muiños <jfontan@gmail.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'cangallo/qcow2'
+require 'cangallo/config'
+require 'cangallo/repo'
+require 'cangallo/cangafile'
+require 'cangallo/libguestfs'
+require 'cangallo/keybase'
+require 'cangallo/version'
+
+class Cangallo
+  def initialize
+    @config = Cangallo::Config.new
+  end
+
+  def repo(name = nil)
+    @config.repo(name)
+  end
+
+  def get_images(repo_name = nil)
+    info = []
+    repos = []
+
+    if repo_name
+      repos = [repo_name]
+    else
+      repos = @config.repos
+    end
+
+    repos.each do |r|
+      repo = self.repo(r)
+
+      repo.images.each do |sha256, image|
+        name = repo.short_name(sha256)
+
+        info << {
+          "repo"    => r,
+          "sha256"  => sha256,
+          "name"    => "#{r}:#{name}",
+          "size"    => image["actual-size"],
+          "parent"  => short_name(image["parent"], r),
+          "description" => image["description"],
+          "available" => File.exist?(repo.image_path(sha256)),
+          "creation-time" => image["creation-time"]
+        }
+      end
+    end
+
+    info
+  end
+
+  def parse_name(name)
+    slices = name.split(':')
+
+    repo = nil
+    name = name
+
+    if slices.length > 1
+      repo = slices[0]
+      name = slices[1]
+    end
+
+    return repo, name
+  end
+
+  def short_name(string, repo = nil)
+    return nil if !string
+
+    img_repo, img_name = parse_name(string)
+    img_repo ||= repo
+
+    image = self.repo(img_repo).find(img_name)
+    name = self.repo(img_repo).short_name(image)
+
+    "#{img_repo}:#{name}"
+  end
+
+  def find(string)
+    repo, name = parse_name(string)
+    return "#{repo}:#{self.repo(repo).find(name)}" if repo
+
+    image = self.repo.find(name)
+    return "#{self.repo.name}:#{image}" if image
+
+    @config.repos.each do |r|
+      image = self.repo(r).find(name)
+      return "#{r}:#{image}" if image
+    end
+
+    nil
+  end
+
+  def get(string)
+    image = find(string)
+    return nil if !image
+
+    repo, name = parse_name(image)
+
+    img = self.repo(repo).get(name)
+
+    img["repo"] = repo if img
+    img
+  end
+end
+

data/lib/cangallo/cangafile.rb

@@ -0,0 +1,187 @@
+
+# vim:tabstop=2:sw=2:et:
+
+# Copyright 2016, Javier Fontán Muiños <jfontan@gmail.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'json'
+require 'systemu'
+require 'tempfile'
+require 'fileutils'
+require 'yaml'
+
+class Cangallo
+
+  class Cangafile
+    attr_accessor :data
+
+    ACTIONS = {
+      "copy" => {
+        "action" => lambda do |input|
+          add_head "copy-in #{input.gsub(" ", ":")}"
+        end
+      },
+
+      "run" => {
+        "type" => [Array, String],
+        "action" => lambda do |input|
+          if input.class == String
+            commands = input.split("\n").reject {|l| l.empty? }
+          else
+            commands = input
+          end
+
+          commands.each do |cmd|
+            add_head "run-command #{cmd}"
+          end
+        end
+      },
+
+      "change" => {
+        "type" => Hash,
+        "action" => lambda do |input|
+          regexp = input["regexp"].gsub("/", "\\/")
+          text = input["text"]
+          file = input["file"]
+          add_head "run-command sed -i 's/#{regexp}/#{text}/g' #{file}"
+        end
+      },
+
+      "delete" => {
+        "action" => lambda do |input|
+          add_head "run-command rm -rf #{input}"
+        end
+      },
+
+      "password" => {
+        "type" => Hash,
+        "action" => lambda do |input|
+          if input["disabled"]
+            password = "disabled"
+          else
+            password = "password:#{input["password"]}"
+          end
+
+          add_parameter "--password '#{input["user"]}:#{password}'"
+        end
+      }
+    }
+
+    def initialize(file)
+      text = File.read(file)
+      @data = YAML.load(text)
+
+      @params = []
+      @head = []
+      @tail = []
+
+      if !@data["tasks"] || @data["tasks"].class != Array
+        raise "No tasks defined or it's not an array"
+      end
+
+      @tasks = @data["tasks"]
+    end
+
+    def render
+      @tasks.each do |task|
+        raise %Q{Task "#{task.inspect}" malformed} if task.class != Hash
+
+        action_name = task.keys.first
+        action_data = task[action_name]
+
+        if !ACTIONS.keys.include?(action_name)
+          raise %Q{Invalid action "#{action_name}"}
+        end
+
+        action = ACTIONS[action_name]
+
+        if action["type"]
+          type = [action["type"]].flatten
+        else
+          type = [String]
+        end
+
+        # Check action value type
+        task_type = action_data.class
+        if !type.include?(task_type)
+          raise %Q{Action parameters for "#{action_name}" must be "#{type.inspect}"}
+        end
+
+        if action["action"]
+          instance_exec(action_data, &action["action"])
+        end
+      end
+
+      return @head + @tail, @params
+    end
+
+    def add_head(str)
+      @head << str
+    end
+
+    def add_tail(str)
+      @tail.unshift(str)
+    end
+
+    def add_parameter(str)
+      @params << str
+    end
+
+    def file_commands
+      text = ""
+
+      if @data["files"]
+        @data["files"].each do |line|
+          l = line.gsub(" ", ":")
+          text << "copy-in #{l}\n"
+        end
+      end
+
+      return text
+    end
+
+    def run_commands
+      text = ""
+
+      if @data["run"]
+        @data["run"].each do |line|
+          text << "run-command #{line}\n"
+        end
+      end
+
+      return text
+    end
+
+    def libguestfs_commands
+      @tasks.each do |task|
+        if task.class != Hash
+          raise "This task is not a hash: #{task}"
+        end
+
+
+      end
+    end
+
+    def libguestfs_commands_old
+      text = file_commands
+      text << run_commands
+      text
+    end
+
+    def parent
+      @data["parent"]
+    end
+  end
+
+end

data/lib/cangallo/config.rb

@@ -0,0 +1,95 @@
+
+# vim:ts=2:sw=2
+
+# Copyright 2016, Javier Fontán Muiños <jfontan@gmail.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'fileutils'
+require 'yaml'
+
+class Cangallo
+  class Config
+    CONFIG_DIR = '.cangallo'
+    CONFIG_FILE = 'config.yaml'
+
+    DEFAULT_CONFIG = <<EOT
+default_repo: default
+repos:
+    default:
+        type: local
+        path: ~/#{CONFIG_DIR}/default
+EOT
+
+    def initialize
+      create_config_dir
+      create_default_config
+      load_conf
+    end
+
+    def repo(name = nil)
+      repo_name = name || @conf['default_repo'] || 'default'
+      raise(%q{Configuration malformed, no 'repos'}) if !@conf['repos']
+
+      repo_conf = @conf['repos'][repo_name]
+      raise(%Q<No repo with name '#{repo_name}'>) if !repo_conf
+      raise(%Q<Repo path no defined for '#{repo_name}'>) if !repo_conf['path']
+
+      path = File.expand_path(repo_conf["path"])
+      repo_conf["path"] = path
+      repo_conf["name"] = repo_name
+      create_repo_dir(path)
+      Cangallo::Repo.new(repo_conf)
+    end
+
+    def load_conf
+      @conf = YAML.load_file(config_file)
+    end
+
+    def create_config_dir
+      if !File.exist?(config_dir)
+        FileUtils.mkdir_p(config_dir)
+      end
+    end
+
+    def create_default_config
+      if !File.exist?(config_file)
+        open(config_file, 'w') do |f|
+          f.write(DEFAULT_CONFIG)
+        end
+
+        load_conf
+        path = File.expand_path(@conf["repos"]["default"]["path"])
+        create_repo_dir(path)
+      end
+    end
+
+    def create_repo_dir(path)
+      if !File.exist?(path)
+        FileUtils.mkdir_p(path)
+      end
+    end
+
+    def config_dir
+      File.join(ENV['HOME'], CONFIG_DIR)
+    end
+
+    def config_file
+      File.join(config_dir, CONFIG_FILE)
+    end
+
+    def repos
+      @conf["repos"].keys
+    end
+  end
+end

data/lib/cangallo/keybase.rb

@@ -0,0 +1,39 @@
+
+# vim:tabstop=2:sw=2:et:
+
+# Copyright 2016, Javier Fontán Muiños <jfontan@gmail.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Cangallo
+
+  module Keybase
+    def self.sign(file)
+      sig_file = "#{file}.sig"
+      cmd = "keybase pgp sign --detached --infile '#{file}' " \
+                                        "--outfile '#{sig_file}'"
+      rc = system(cmd)
+      raise "Error executing keybase sign command" if !rc
+    end
+
+    def self.verify(file)
+      sig_file = "#{file}.sig"
+      cmd = "keybase pgp verify --detached '#{sig_file}' " \
+                               "--infile '#{file}'"
+      rc = system(cmd)
+      raise "Error executing keybase verify command" if !rc
+    end
+  end
+end
+
+

data/lib/cangallo/libguestfs.rb

@@ -0,0 +1,46 @@
+
+# vim:tabstop=2:sw=2:et:
+
+# Copyright 2016, Javier Fontán Muiños <jfontan@gmail.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'json'
+require 'systemu'
+require 'tempfile'
+require 'fileutils'
+
+class Cangallo
+
+  class LibGuestfs
+    def self.virt_customize(image, commands, params = "")
+      cmd_file = Tempfile.new("canga")
+
+      cmd_file.puts(commands)
+      cmd_file.close
+
+      #rc = system("virt-customize -v -x -a #{image} --commands-from-file #{cmd_file.path}")
+      rc = system("virt-customize -a #{image} #{params.join(" ")} " <<
+                  "--commands-from-file #{cmd_file.path}")
+      cmd_file.unlink
+
+      return rc
+    end
+
+    def self.virt_sparsify(image)
+      rc = system("virt-sparsify --in-place #{image}")
+
+      return rc
+    end
+  end
+end

data/lib/cangallo/qcow2.rb

@@ -0,0 +1,151 @@
+
+# vim:tabstop=2:sw=2:et:
+
+# Copyright 2016, Javier Fontán Muiños <jfontan@gmail.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'json'
+require 'systemu'
+require 'tempfile'
+require 'fileutils'
+
+class Cangallo
+
+  class Qcow2
+    attr_reader :path
+
+    def initialize(path=nil)
+      @path=path
+    end
+
+    def info
+      res = execute :info, '--output=json', @path
+
+      JSON.parse res
+    end
+
+    def compress(destination = nil, parent = nil)
+      copy(destination, :parent => parent, :compress => true)
+    end
+
+    def convert(destination, options = {})
+      command = [:convert]
+      command << '-c' if options[:compress]
+      command << "-O #{options[:format]}" if options[:format]
+      command += [@path, destination]
+
+      execute(*command)
+    end
+
+    def copy(destination = nil, options = {})
+      ops = {
+        :parent => nil,
+        :compress => true,
+        :only_copy => false
+      }.merge(options)
+
+      parent = ops[:parent]
+
+      new_path = destination || @path + '.compressed'
+
+      command = [:convert, "-p", "-O qcow2"]
+      #command = ["convert", "-p", "-O qcow2"]
+      command << '-c' if ops[:compress]
+      command << "-o backing_file=#{parent}" if parent
+      command += [@path, new_path]
+
+      if ops[:only_copy]
+        FileUtils.cp(@path, new_path)
+      else
+        execute *command
+      end
+
+      # pp command
+      # system(*command)
+
+      if !destination
+        begin
+          File.rm @path
+          File.mv new_path, @path
+        ensure
+          File.rm new_path if File.exist? new_path
+        end
+      else
+        @path = new_path
+      end
+    end
+
+    def sparsify(destination)
+      parent = info['backing_file']
+      parent_options = ''
+
+      parent_options = "-o backing_file=#{parent}" if parent
+
+      command = "TMPDIR=#{File.dirname(destination)} virt-sparsify #{parent_options} #{@path} #{destination}"
+      status, stdout, stderr = systemu command
+    end
+
+    def sha(ver = 256)
+      command = "guestfish --progress-bars --ro -a #{@path} " <<
+                "run : checksum-device sha#{ver} /dev/sda"
+      %x{#{command}}.strip
+    end
+
+    def sha1
+      sha(1)
+    end
+
+    def sha256
+      sha(256)
+    end
+
+    def rebase(new_base)
+      execute :rebase, '-u', "-b #{new_base}", @path
+    end
+
+    def execute(command, *params)
+      self.class.execute(command, params)
+    end
+
+    def self.execute(command, *params)
+      command = "qemu-img #{command} #{params.join(' ')}"
+      STDERR.puts command
+
+      status, stdout, stderr = systemu command
+
+      if status.success?
+        stdout
+      else
+        raise stderr
+      end
+    end
+
+    def self.create_from_base(origin, destination, size=nil)
+      cmd = [:create, '-f qcow2', "-o backing_file=#{origin}", destination]
+      cmd << size if size
+
+      execute(*cmd)
+    end
+
+    def self.create(image, parent=nil, size=nil)
+      cmd = [:create, '-f qcow2']
+      cmd << "-o backing_file=#{parent}" if parent
+      cmd << image
+      cmd << size if size
+
+      execute(*cmd)
+    end
+  end
+
+end

data/lib/cangallo/repo.rb

@@ -0,0 +1,276 @@
+
+# vim:ts=2:sw=2
+
+# Copyright 2016, Javier Fontán Muiños <jfontan@gmail.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "yaml"
+require "open-uri"
+require "uri"
+
+class Cangallo
+
+  class Repo
+    attr_reader :images, :tags, :path, :name
+
+    VERSION = 0
+
+    def initialize(conf)
+      @conf = conf
+      @path = File.expand_path(@conf["path"])
+      @name = @conf["name"]
+      @type = @conf["type"]
+      @url  = @conf["url"]
+
+      if !@type && @url
+        @type = "remote"
+      else
+        @type = "local"
+      end
+
+      read_index
+    end
+
+    def index_data(images = {}, tags = {}, version = VERSION)
+      {
+        "version" => version,
+        "images"  => images,
+        "tags"    => tags
+      }
+    end
+
+    def index_path
+      metadata_path("index")
+    end
+
+    def read_index(index = nil)
+      if !index
+        if File.exist?(index_path)
+          data = YAML.load(File.read(index_path))
+        else
+          data = index_data()
+        end
+      else
+        data = YAML.load(index)
+      end
+
+      @images       = data["images"]
+      @tags         = data["tags"]
+      @reverse_tags = @tags.invert
+    end
+
+    def write_index
+      data = index_data(@images, @tags)
+
+      open(metadata_path("index"), "w") do |f|
+        f.write(data.to_yaml)
+      end
+    end
+
+    def metadata_path(name)
+      File.join(@path, "#{name}.yaml")
+    end
+
+    def image_path(name)
+      File.join(@path, "#{name}.qcow2")
+    end
+
+    def remote_url(name)
+      URI.join(@url, name)
+    end
+
+    def remote_image_url(name)
+      remote_url("#{name}.qcow2")
+    end
+
+    def add(name, data)
+      data["creation-time"] = Time.now
+      data["sha256"] = name
+      @images[name] = data
+    end
+
+    def add_image(file, data = {})
+      parent_sha256 = nil
+      parent = nil
+      parent_path = nil
+
+      only_copy = data.delete("only_copy")
+
+      if data["parent"]
+        parent_sha256 = data["parent"]
+        parent = self.images[parent_sha256]
+
+        if !parent
+          raise "Parent not found"
+        end
+
+        parent_path = File.expand_path(self.image_path(parent_sha256))
+      end
+
+      puts "Calculating image sha256 with libguestfs (it will take some time)"
+      qcow2 = Cangallo::Qcow2.new(file)
+      sha256 = qcow2.sha256
+      sha256.strip! if sha256
+
+      puts "Image SHA256: #{sha256}"
+
+      puts "Copying file to repository"
+      image_path = self.image_path(sha256)
+      qcow2.copy(image_path, parent: parent_path, only_copy: only_copy)
+
+      qcow2 = Cangallo::Qcow2.new(image_path)
+      info = qcow2.info
+
+      info_data = info.select do |k,v|
+        %w{virtual-size format actual-size format-specific}.include?(k)
+      end
+
+      data.merge!(info_data)
+
+      data["file-sha256"] = Digest::SHA256.file(file).hexdigest
+
+      if parent
+        qcow2.rebase("#{parent_sha256}.qcow2")
+        data["parent"] = parent_sha256
+      end
+
+      self.add(sha256, data)
+      self.write_index
+
+      sha256
+    end
+
+    def del_image(image)
+      sha256 = find(image)
+
+      raise %Q{Image "#{image}" does not exist} if !sha256
+
+      path = image_path(sha256)
+      File.delete(path)
+
+      @images.delete(sha256)
+      write_index
+    end
+
+    def add_tag(tag, image)
+      img = find(image)
+      @tags[tag] = img
+      write_index
+    end
+
+    def del_tag(tag)
+      @tags.delete(tag)
+      write_index
+    end
+
+    def find(name, search_tags = true)
+      length = name.length
+      found = @images.select do |sha256, data|
+        sha256[0, length] == name
+      end
+
+      if found && found.length > 0
+        return found.first.first
+      end
+
+      if search_tags
+        found = @tags.select do |tag, sha256|
+          tag == name
+        end
+      end
+
+      if found && found.length > 0
+        return found.first[1]
+      end
+
+      nil
+    end
+
+    def get(name)
+      image = find(name)
+
+      return nil if !image
+
+      @images[image]
+    end
+
+    def ancestors(name)
+      ancestors = []
+
+      image = get(name)
+      ancestors << image["sha256"]
+
+      while image["parent"]
+        image = get(image["parent"])
+        ancestors << image["sha256"]
+      end
+
+      ancestors
+    end
+
+    def url
+      @conf["url"]
+    end
+
+    def fetch
+      return nil if @conf["type"] != "remote"
+
+      uri = remote_url("index.yaml")
+
+      open(uri, "r") do |f|
+        data = f.read
+        read_index(data)
+      end
+
+      write_index
+    end
+
+    def sign
+      Keybase.sign(index_path)
+    end
+
+    def verify
+      Keybase.verify(index_path)
+    end
+
+    def pull(name)
+      image = get(name)
+
+      raise "Image not found" if !image
+
+      sha256 = image["sha256"]
+      image_url = remote_image_url(sha256)
+      image_path = image_path(sha256)
+      cmd = "curl -o '#{image_path}' '#{image_url}'"
+
+      STDERR.puts(cmd)
+
+      system(cmd)
+    end
+
+    def short_name(sha256)
+      tag = @reverse_tags[sha256]
+
+      if tag
+        name = "#{tag}"
+      else
+        name = "#{sha256[0..15]}"
+      end
+
+      name
+    end
+  end
+
+end
+

data/lib/cangallo/version.rb

@@ -0,0 +1,20 @@
+
+# vim:ts=2:sw=2
+
+# Copyright 2016, Javier Fontán Muiños <jfontan@gmail.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Cangallo
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: cangallo
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Javier Fontan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: systemu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: VM Image manager
+email: jfontan@gmail.com
+executables:
+- canga
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/canga
+- lib/cangallo.rb
+- lib/cangallo/cangafile.rb
+- lib/cangallo/config.rb
+- lib/cangallo/keybase.rb
+- lib/cangallo/libguestfs.rb
+- lib/cangallo/qcow2.rb
+- lib/cangallo/repo.rb
+- lib/cangallo/version.rb
+homepage: http://canga.io
+licenses:
+- Apache-2.0
+metadata: {}
+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: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Cangallo!!
+test_files: []
+has_rdoc: