tinet 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f3759871bec017bb9c62083793496f041da97ea833be5ff9ad337c11fdc50854
+  data.tar.gz: 0d61c7aff75feef1ec886e10fdb81a60ba54674fc933d757c63800e2df0081f4
+SHA512:
+  metadata.gz: 007d93174d1823b979983739553f7626d9826dba2727270aef246dcbc99d87d46ecb4a00bdf70eebdf7b86fe21fc8eea3429f5ff25399441ff788f58b4d23a78
+  data.tar.gz: 5748d97ecbe6812c4bca50dee08b1b0f915f461dfcca5df178e1ba3680000d1205f5ff8f27b0aa898c44043af288047f69b26debbeaae559c8c512652f824afa

data/.gitignore

@@ -0,0 +1,50 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Change Log
+
+## [Unreleased](https://github.com/koki-sato/tinet-rb/compare/v0.0.2...HEAD)
+
+## 0.0.2
+
+- Fix bugs
+
+## 0.0.1
+
+- Basic implementation

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in tinet.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Koki Sato
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,40 @@
+# tinet-rb
+
+Ruby implement of [slankdev/tinet](https://github.com/slankdev/tinet).
+
+:warning: **This is now prototype version. And also it is incompatible with YAML config format in [slankdev/tinet](https://github.com/slankdev/tinet).**
+
+## Requirements
+
+- Docker
+- Open vSwitch
+
+## Install
+
+```
+$ gem install tinet
+```
+
+## Usage
+
+```
+$ tinet [OPTIONS] COMMAND
+
+Options:
+  -f, [--specfile=SPECFILE]  # Specify specification YAML file (Default: ./spec.yml)
+  -d, [--dry-run]            # Print the recipes that are needed to execute
+  -v, [--version]            # Show the TINET version information
+
+Commands:
+  tinet build [OPTIONS]              # Build Docker images from the spec file
+  tinet conf [OPTIONS]               # Execute commands in a running container
+  tinet down [OPTIONS]               # Stop and remove containers
+  tinet exec [OPTIONS] NODE COMMAND  # Execute a command in a running container
+  tinet help [COMMAND]               # Describe available commands or one specific command
+  tinet init                         # Generate template spec file
+  tinet ps [OPTIONS]                 # List services
+  tinet pull [OPTIONS]               # Pull service images
+  tinet restart [OPTIONS]            # Down and Up running containers
+  tinet up [OPTIONS]                 # Create and start containers
+  tinet version                      # Show the TINET version information
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/tinet

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "tinet"
+
+Tinet::CLI.start(ARGV)

data/lib/tinet.rb

@@ -0,0 +1,8 @@
+require "tinet/version"
+require "tinet/setting"
+require "tinet/cli"
+
+module Tinet
+  class InvalidYAMLError < StandardError; end
+  class InvalidTypeError < StandardError; end
+end

data/lib/tinet/cli.rb

@@ -0,0 +1,119 @@
+require "thor"
+require "tinet/setting"
+require "tinet/command/build"
+require "tinet/command/conf"
+require "tinet/command/down"
+require "tinet/command/exec"
+require "tinet/command/init"
+require "tinet/command/ps"
+require "tinet/command/pull"
+require "tinet/command/up"
+
+module Tinet
+  class CLI < Thor
+    map %w[--version -v] => :version
+
+    desc 'init', 'Generate template spec file'
+    option :version, aliases: '-v', type: :boolean, default: false, desc: 'Show the TINET version information'
+    def init
+      return version if options[:version]
+      Tinet::Command::Init.new.run
+    end
+
+    desc 'ps [OPTIONS]', 'List services'
+    option :all, aliases: '-a', type: :boolean, desc: 'Show all containers (default shows just running)'
+    option 'dry-run', aliases: '-d', type: :boolean, default: false, desc: 'Print the recipes that are needed to execute'
+    option :version, aliases: '-v', type: :boolean, default: false, desc: 'Show the TINET version information'
+    def ps
+      return version if options[:version]
+      Tinet::Command::Ps.new(options).run
+    end
+
+    desc 'up [OPTIONS]', 'Create and start containers'
+    option :specfile, aliases: '-f', type: :string, default: Tinet::DEFAULT_SPECFILE_PATH, desc: 'Specify specification YAML file'
+    option 'dry-run', aliases: '-d', type: :boolean, default: false, desc: 'Print the recipes that are needed to execute'
+    option :version, aliases: '-v', type: :boolean, default: false, desc: 'Show the TINET version information'
+    def up
+      return version if options[:version]
+      Tinet::Command::Up.new(options).run
+      Tinet::Command::Conf.new(options).run
+    end
+
+    desc 'down [OPTIONS]', 'Stop and remove containers'
+    option :specfile, aliases: '-f', type: :string, default: Tinet::DEFAULT_SPECFILE_PATH, desc: 'Specify specification YAML file'
+    option 'dry-run', aliases: '-d', type: :boolean, default: false, desc: 'Print the recipes that are needed to execute'
+    option :version, aliases: '-v', type: :boolean, default: false, desc: 'Show the TINET version information'
+    def down
+      return version if options[:version]
+      Tinet::Command::Down.new(options).run
+    end
+
+    desc 'pull [OPTIONS]', 'Pull service images'
+    option :specfile, aliases: '-f', type: :string, default: Tinet::DEFAULT_SPECFILE_PATH, desc: 'Specify specification YAML file'
+    option 'dry-run', aliases: '-d', type: :boolean, default: false, desc: 'Print the recipes that are needed to execute'
+    option :version, aliases: '-v', type: :boolean, default: false, desc: 'Show the TINET version information'
+    def pull
+      return version if options[:version]
+      Tinet::Command::Pull.new(options).run
+    end
+
+    desc 'exec [OPTIONS] NODE COMMAND', 'Execute a command in a running container'
+    option :specfile, aliases: '-f', type: :string, default: Tinet::DEFAULT_SPECFILE_PATH, desc: 'Specify specification YAML file'
+    option 'dry-run', aliases: '-d', type: :boolean, default: false, desc: 'Print the recipes that are needed to execute'
+    option :version, aliases: '-v', type: :boolean, default: false, desc: 'Show the TINET version information'
+    def exec(node, command)
+      return version if options[:version]
+      Tinet::Command::Exec.new(options).run(node, command)
+    end
+
+    desc 'build [OPTIONS]', 'Build Docker images from the spec file'
+    option :specfile, aliases: '-f', type: :string, default: Tinet::DEFAULT_SPECFILE_PATH, desc: 'Specify specification YAML file'
+    option 'dry-run', aliases: '-d', type: :boolean, default: false, desc: 'Print the recipes that are needed to execute'
+    option :version, aliases: '-v', type: :boolean, default: false, desc: 'Show the TINET version information'
+    def build
+      return version if options[:version]
+      Tinet::Command::Build.new(options).run
+    end
+
+    desc 'conf [OPTIONS]', 'Execute commands in a running container'
+    option :specfile, aliases: '-f', type: :string, default: Tinet::DEFAULT_SPECFILE_PATH, desc: 'Specify specification YAML file'
+    option 'dry-run', aliases: '-d', type: :boolean, default: false, desc: 'Print the recipes that are needed to execute'
+    option :version, aliases: '-v', type: :boolean, default: false, desc: 'Show the TINET version information'
+    def conf
+      return version if options[:version]
+      Tinet::Command::Conf.new(options).run
+    end
+
+    desc 'restart [OPTIONS]', 'Down and Up running containers'
+    option :specfile, aliases: '-f', type: :string, default: Tinet::DEFAULT_SPECFILE_PATH, desc: 'Specify specification YAML file'
+    option 'dry-run', aliases: '-d', type: :boolean, default: false, desc: 'Print the recipes that are needed to execute'
+    option :version, aliases: '-v', type: :boolean, default: false, desc: 'Show the TINET version information'
+    def restart
+      return version if options[:version]
+      Tinet::Command::Down.new(options).run
+      Tinet::Command::Up.new(options).run
+    end
+
+    desc 'version', 'Show the TINET version information'
+    def version
+      puts "TINET version: #{Tinet::VERSION}"
+    end
+
+    # @note Override {Thor#help}
+    def help(command = nil, subcommand = false)
+      if command.nil?
+        puts <<-USAGE
+Usage:
+  tinet [OPTIONS] COMMAND
+
+Options:
+  -f, [--specfile=SPECFILE]  # Specify specification YAML file (Default: ./spec.yml)
+  -d, [--dry-run]            # Print the recipes that are needed to execute
+  -v, [--version]            # Show the TINET version information
+
+USAGE
+      end
+      super
+    end
+  end
+end

data/lib/tinet/command/base.rb

@@ -0,0 +1,130 @@
+require "tinet/data"
+require "tinet/link"
+require "tinet/shell"
+
+module Tinet
+  module Command
+    class Base
+      include Shell
+
+      def initialize(options = {})
+        @options = options
+        check_docker_installed unless dry_run
+        check_ovs_vsctl_installed unless dry_run
+      end
+
+      protected
+
+      # @return [Logger]
+      def logger
+        Tinet.logger
+      end
+
+      # @return [String]
+      def specfile
+        @options.fetch(:specfile, '')
+      end
+
+      # @return [boolean]
+      def dry_run
+        @options.fetch('dry-run', false)
+      end
+
+      # @return [Tinet::Data, nil]
+      def data
+        return nil if specfile.nil? || specfile.empty?
+        @data ||= Tinet::Data.parse(specfile)
+      end
+
+      # @return [Array<Tinet::Node>, nil]
+      def nodes
+        data.nodes unless data.nil?
+      end
+
+      # @return [Array<Tinet::Switch>, nil]
+      def switches
+        data.switches unless data.nil?
+      end
+
+      # @return [Array<Tinet::Link>]
+      def links
+        return nil if data.nil?
+        @links ||= Tinet::Link.link(nodes, switches)
+      end
+
+      # @param name [String]
+      # @return [String]
+      def namespaced(name)
+        "#{Tinet.namespace}-#{name}"
+      end
+
+      # @note Override {Tinet::Shell#sh}
+      def sh(command, dry_run: dry_run(), print: true, continue: false)
+        super
+      end
+
+      def mount_docker_netns(container, netns)
+        if dry_run
+          logger.info "PID=`sudo docker inspect #{container} -f {{.State.Pid}}`"
+          pid = '$PID'
+        else
+          pid, * = sudo "docker inspect #{container} -f {{.State.Pid}}"
+        end
+        sudo 'mkdir -p /var/run/netns'
+        sudo "ln -s /proc/#{pid}/ns/net /var/run/netns/#{netns}"
+      end
+
+      def exec_pre_cmd
+        data.options[:pre_cmd].each { |cmd| sudo command }
+      end
+
+      def exec_pre_init
+        data.options[:pre_init].each { |cmd| sudo command }
+      end
+
+      def exec_post_init
+        data.options[:post_init].each { |cmd| sudo command }
+      end
+
+      def exec_pre_conf
+        data.options[:pre_conf].each { |cmd| sudo command }
+      end
+
+      def exec_post_conf
+        data.options[:post_conf].each { |cmd| sudo command }
+      end
+
+      def exec_pre_down
+        data.options[:pre_down].each { |cmd| sudo command }
+      end
+
+      def exec_post_down
+        data.options[:post_down].each { |cmd| sudo command }
+      end
+
+      private
+
+      # @return [boolean]
+      def command_exist?(command)
+        *, status = sh "which #{command}", print: false, continue: true
+        status.success?
+      end
+
+      def check_docker_installed
+        unless command_exist?('docker')
+          message = 'ERROR: Docker is not installed. TINET requires Docker.'
+          logger.error(message)
+          exit(1)
+        end
+      end
+
+      def check_ovs_vsctl_installed
+        unless command_exist?('ovs-vsctl')
+          message = 'ERROR: Open vSwitch is not installed. TINET requires Open vSwitch.'
+          logger.error(message)
+          exit(1)
+        end
+      end
+    end
+  end
+end

data/lib/tinet/command/build.rb

@@ -0,0 +1,11 @@
+require "tinet/command/base"
+
+module Tinet
+  module Command
+    class Build < Base
+      def run
+        logger.error 'TODO: Implement'
+      end
+    end
+  end
+end

data/lib/tinet/command/conf.rb

@@ -0,0 +1,25 @@
+require "tinet/command/base"
+
+module Tinet
+  module Command
+    class Conf < Base
+      def run
+        exec_pre_cmd
+        exec_pre_conf
+
+        nodes.each do |node|
+          node.cmds.each do |cmd|
+            case node.type
+            when :docker
+              sudo "docker exec #{namespaced(node.name)} #{cmd} > /dev/null"
+            when :netns
+              sudo "ip netns exec #{namespaced(node.name)} #{cmd} > /dev/null"
+            end
+          end
+        end
+
+        exec_post_conf
+      end
+    end
+  end
+end

data/lib/tinet/command/down.rb

@@ -0,0 +1,43 @@
+require "tinet/command/base"
+
+module Tinet
+  module Command
+    class Down < Base
+      def run
+        exec_pre_cmd
+        exec_pre_down
+
+        nodes.each do |node|
+          node.interfaces.each do |interface|
+            if interface.type == :phys
+              detach_physnet_from_docker("#{namespaced(node.name)}", interface.name)
+            end
+          end
+        end
+
+        nodes.each do |node|
+          case node.type
+          when :docker
+            sudo "docker stop #{namespaced(node.name)}"
+          when :netns
+            sudo "ip netns del #{namespaced(node.name)}"
+          end
+        end
+
+        switches.each do |switch|
+          sudo "ovs-vsctl del-br #{namespaced(switch.name)}"
+        end
+
+        exec_post_down
+      end
+
+      private
+
+      def detach_physnet_from_docker(container, ifname)
+        mount_docker_netns(container, container)
+        sudo "ip netns exec #{container} ip link set #{ifname} netns 1"
+        sudo "ip netns del #{container}"
+      end
+    end
+  end
+end

data/lib/tinet/command/exec.rb

@@ -0,0 +1,18 @@
+require "tinet/command/base"
+
+module Tinet
+  module Command
+    class Exec < Base
+      def run(node_name, command)
+        node = nodes.find { |node| node.name == node_name }
+        raise "No such container: #{node_name}" if node.nil?
+        case node.type
+        when :docker
+          sudo "docker exec -it #{namespaced(node.name)} #{command}"
+        when :netns
+          sudo "ip netns exec #{namespaced(node.name)} #{command}"
+        end
+      end
+    end
+  end
+end

data/lib/tinet/command/init.rb

@@ -0,0 +1,17 @@
+require "fileutils"
+require "tinet/setting"
+require "tinet/shell"
+require "tinet/command/base"
+
+module Tinet
+  module Command
+    class Init < Base
+      def run
+        template = File.join(Tinet::ROOT, 'spec.template.yml')
+        specfile = Tinet::DEFAULT_SPECFILE_PATH
+        FileUtils.cp(template, specfile)
+        logger.info 'Initialized. Check spec.yml'
+      end
+    end
+  end
+end

data/lib/tinet/command/ps.rb

@@ -0,0 +1,28 @@
+require "tinet/command/base"
+
+module Tinet
+  module Command
+    class Ps < Base
+      def run
+        if all
+          stdout, * = sudo "docker ps -a -f name=#{Tinet.namespace}"
+        else
+          stdout, * = sudo "docker ps -f name=#{Tinet.namespace}"
+        end
+
+        unless dry_run
+          logger.info 'TINET Docker Containers'
+          logger.info '-' * 50
+          logger.info stdout
+        end
+      end
+
+      private
+
+      # @return [boolean]
+      def all
+        @options[:all]
+      end
+    end
+  end
+end

data/lib/tinet/command/pull.rb

@@ -0,0 +1,16 @@
+require "tinet/command/base"
+
+module Tinet
+  module Command
+    class Pull < Base
+      def run
+        nodes.each do |node|
+          unless node.image.nil?
+            stdout, * = sudo "docker pull #{node.image}"
+            logger.info stdout unless dry_run
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tinet/command/up.rb

@@ -0,0 +1,104 @@
+require "tinet/command/base"
+
+module Tinet
+  module Command
+    class Up < Base
+      def run
+        exec_pre_cmd
+        exec_pre_init
+
+        # Create Nodes and Switches
+        nodes.each { |node| node_up(node) }
+        switches.each { |switch| switch_up(switch) }
+
+        # Create Links
+        links.each { |link| link_up(link) }
+
+        # Attach physnet / veth to Conitaner
+        nodes.each do |node|
+          node.interfaces.each do |interface|
+            case interface.type
+            when :phys
+              koko_physnet("#{namespaced(node.name)}", interface.name)
+            when :veth
+              sudo "ip link add #{interface.name} type veth peer name #{interface.args}"
+              koko_physnet("#{namespaced(node.name)}", interface.name)
+              sudo "ip link set #{interface.args} up"
+            end
+          end
+        end
+
+        exec_post_init
+      end
+
+      private
+
+      def all
+        @options[:all]
+      end
+
+      # @param node [Tinet::Node]
+      def node_up(node)
+        case node.type
+        when :docker
+          sudo "docker run -td --hostname #{node.name} --net=none --name #{namespaced(node.name)} --rm --privileged #{node.image}"
+        when :netns
+          sudo "ip netns add #{namespaced(node.name)}"
+        end
+      end
+
+      # @param switch [Tinet::Switch]
+      def switch_up(switch)
+        sudo "ovs-vsctl add-br #{namespaced(switch.name)}"
+        sudo "ip link set #{namespaced(switch.name)} up"
+      end
+
+      # @param link [Tinet::Link]
+      def link_up(link)
+        left, right = link.left, link.right
+        case link.type
+        when :n2n
+          mount_docker_netns(namespaced(left.node.name), namespaced(left.node.name)) if left.node.type == :docker
+          mount_docker_netns(namespaced(right.node.name), namespaced(right.node.name)) if right.node.type == :docker
+          sudo "ip link add #{left.name} netns #{namespaced(left.node.name)} type veth peer name #{right.name} netns #{namespaced(right.node.name)}"
+          sudo "ip netns exec #{namespaced(left.node.name)} ip link set #{left.name} up"
+          sudo "ip netns exec #{namespaced(right.node.name)} ip link set #{right.name} up"
+          sudo "ip netns del #{namespaced(left.node.name)}" if left.node.type == :docker
+          sudo "ip netns del #{namespaced(right.node.name)}" if right.node.type == :docker
+        when :s2n
+          case right.node.type
+          when :docker
+            kokobr(namespaced(left.switch.name), namespaced(right.node.name), right.name)
+          when :netns
+            kokobr_netns(namespaced(left.switch.name), namespaced(right.node.name), right.name)
+          end
+        end
+      end
+
+      def kokobr(bridge, container, ifname)
+        mount_docker_netns(container, container)
+        sudo "ip link add name #{ifname} type veth peer name #{container}-#{ifname}"
+        sudo "ip link set dev #{ifname} netns #{container}"
+        sudo "ip link set #{container}-#{ifname} up"
+        sudo "ip netns exec #{container} ip link set #{ifname} up"
+        sudo "ip netns del #{container}"
+        sudo "ovs-vsctl add-port #{bridge} #{container}-#{ifname}"
+      end
+
+      def kokobr_netns(bridge, container, ifname)
+        sudo "ip link add name #{ifname} type veth peer name #{container}-#{ifname}"
+        sudo "ip link set dev #{ifname} netns #{container}"
+        sudo "ip link set #{container}-#{ifname} up"
+        sudo "ip netns exec #{container} ip link set #{ifname} up"
+        sudo "ovs-vsctl add-port #{bridge} #{container}-#{ifname}"
+      end
+
+      def koko_physnet(container, netif)
+        mount_docker_netns(container, container)
+        sudo "ip link set dev #{netif} netns #{container}"
+        sudo "ip netns exec #{container} ip link set #{netif} up"
+        sudo "ip netns del #{container}"
+      end
+    end
+  end
+end

data/lib/tinet/data.rb

@@ -0,0 +1,54 @@
+require "yaml"
+require "tinet/node"
+require "tinet/switch"
+
+module Tinet
+  class Data
+    class << self
+      # @param yaml_path [String]
+      # @return [Tinet::Data]
+      def parse(yaml_path)
+        yaml = YAML.load_file(yaml_path)
+        raise InvalidYAMLError, "Nodes must be array" unless yaml['nodes'].is_a?(Array)
+        raise InvalidYAMLError, "Switches must be array" unless yaml['switches'].is_a?(Array)
+
+        namespace = yaml.fetch('meta', {}).fetch('namespace', nil)
+        Tinet.namespace = namespace unless namespace.nil? || namespace.empty?
+
+        nodes = yaml['nodes'].map { |node| Tinet::Node.parse(node) }
+        switches = yaml['switches'].map { |switch| Tinet::Switch.parse(switch) }
+        options = {
+          pre_cmd: fetch(yaml, 'pre_cmd'),
+          pre_init: fetch(yaml, 'pre_init'),
+          post_init: fetch(yaml, 'post_init'),
+          pre_conf: fetch(yaml, 'pre_conf'),
+          post_conf: fetch(yaml, 'post_conf'),
+          pre_down: fetch(yaml, 'pre_down'),
+          post_down: fetch(yaml, 'post_down')
+        }
+
+        self.new(nodes, switches, options)
+      end
+
+      private
+
+      # @param yaml [Hash]
+      # @param key [String]
+      # @return [Array<String>]
+      def fetch(yaml, key)
+        yaml.fetch(key, {}).fetch('cmds', []).map { |cmd| cmd['cmd'] || cmd }
+      end
+    end
+
+    attr_reader :nodes, :switches, :options
+
+    # @param nodes [Array<Tinet::Node>]
+    # @param switches [Array<Tinet::Switch>]
+    # @param options [Hash{Symbol => Array<String>}]
+    def initialize(nodes, switches, options)
+      @nodes = nodes
+      @switches = switches
+      @options = options
+    end
+  end
+end

data/lib/tinet/link.rb

@@ -0,0 +1,65 @@
+module Tinet
+  class Link
+    TYPES = %w(n2n s2n).freeze
+
+    class << self
+      # @param nodes [Array<Tinet::Node>]
+      # @param switches [Array<Tinet::Switch>]
+      # @return [Array<Tinet::Link>]
+      def link(nodes, switches)
+        link_n2n(nodes) + link_s2n(nodes, switches)
+      end
+
+      # @param nodes [Array<Tinet::Node>]
+      # @return [Array<Tinet::Link>]
+      def link_n2n(nodes)
+        list, index = [], {}
+        nodes.each do |node|
+          node.interfaces.each do |interface|
+            if interface.type == :direct
+              key = "#{interface.args}-#{node.name}##{interface.name}"  # example: C0#net0-C1#net0
+              if index.key?(key)
+                list << self.new(index[key], interface, :n2n)
+              else
+                key = "#{node.name}##{interface.name}-#{interface.args}"  # example: C1#net0-C0#net0
+                index[key] = interface
+              end
+            end
+          end
+        end
+        list
+      end
+
+      # @param nodes [Array<Tinet::Node>]
+      # @param switches [Array<Tinet::Switch>]
+      # @return [Array<Tinet::Link>]
+      def link_s2n(nodes, switches)
+        list, index = [], {}
+        nodes.each do |node|
+          node.interfaces.each do |interface|
+            key = "#{node.name}-#{interface.args}"  # example: C0-B0
+            index[key] = interface if interface.type == :bridge
+          end
+        end
+        switches.each do |switch|
+          switch.interfaces.each do |interface|
+            key = "#{interface.args}-#{switch.name}"  # example: C0-B0
+            list << self.new(interface, index[key], :s2n) if index.key?(key)
+          end
+        end
+        list
+      end
+    end
+
+    attr_reader :left, :right, :type
+
+    # @param left [Tinet::Node::Interfase, Tinet::Switch::Interfase]
+    # @param right [Tinet::Node::Interfase]
+    # @param type [Symbol]
+    def initialize(left, right, type)
+      @left = left
+      @right = right
+      @type = type
+    end
+  end
+end

data/lib/tinet/node.rb

@@ -0,0 +1,65 @@
+module Tinet
+  class Node
+    TYPES = %w(docker netns).freeze
+
+    # @param node_hash [Hash]
+    # @return [Tinet::Node]
+    def self.parse(node_hash)
+      name, type, interfaces = node_hash['name'], node_hash['type'], node_hash['interfaces']
+      raise InvalidYAMLError, "Node name is missing" if name.nil? || name.empty?
+      raise InvalidTypeError, "Unknown node type: #{type}" unless TYPES.include?(type)
+      raise InvalidYAMLError, "Node interfaces must be array" unless interfaces.is_a?(Array)
+
+      interfaces = interfaces.map { |interface| Interfase.parse(interface) }
+      cmds = node_hash.fetch('cmds', []).map { |cmd| cmd['cmd'] || cmd }
+      self.new(name, type.to_sym, node_hash['image'], node_hash['build'], interfaces, cmds)
+    end
+
+    attr_reader :name, :type, :image, :build, :interfaces, :cmds
+
+    # @param name [String]
+    # @param type [Symbol]
+    # @param image [String, nil]
+    # @param build [String, nil]
+    # @param interfaces [Array<Tinet::Node::Interfase>]
+    # @param cmds [Array<String>]
+    def initialize(name, type, image, build, interfaces, cmds)
+      @name = name
+      @type = type
+      @image = image
+      @build = build
+      @interfaces = interfaces
+      @cmds = cmds
+      interfaces.each { |interface| interface.node = self }
+    end
+
+    class Interfase
+      TYPES = %w(direct bridge veth phys).freeze
+
+      # @param interface_hash [Hash]
+      # @return [Tinet::Node::Interfase]
+      def self.parse(interface_hash)
+        name, type, args = interface_hash['name'], interface_hash['type'], interface_hash['args']
+        raise InvalidYAMLError, "Interfase name is missing" if name.nil? || name.empty?
+        raise InvalidTypeError, "Unknown interface type: #{type}" unless TYPES.include?(type)
+        self.new(name, type.to_sym, args)
+      end
+
+      attr_reader :name, :type, :args, :node
+
+      # @param name [String]
+      # @param type [Symbol]
+      # @param args [String, nil]
+      def initialize(name, type, args)
+        @name = name
+        @type = type.to_sym
+        @args = args
+        @node = nil
+      end
+
+      def node=(node)
+        @node = node
+      end
+    end
+  end
+end

data/lib/tinet/setting.rb

@@ -0,0 +1,54 @@
+require "logger"
+
+module Tinet
+  class Setting
+    ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
+    DEFAULT_SPECFILE_PATH = './spec.yml'.freeze
+
+    # @return [String]
+    def root
+      ROOT
+    end
+
+    # @return [String]
+    def namespace
+      @namespace ||= 'tinet'
+    end
+
+    # @param namespace [String]
+    # @return [String]
+    def namespace=(namespace)
+      @namespace = namespace
+    end
+
+    # @return [Logger]
+    def logger
+      @logger ||= Logger.new($stderr).tap do |logger|
+        logger.formatter = proc { |_sev, _dtm, _name, message| message + "\n" }
+        logger.level = Logger::INFO
+      end
+    end
+
+    # @param logger [Logger]
+    # @return [Logger]
+    def logger=(logger)
+      @logger = logger
+    end
+  end
+
+  SettingSingleton = Setting.new
+
+  class << self
+    def const_missing(name)
+      Setting.const_get name
+    rescue NameError
+      super
+    end
+
+    def method_missing(method, *args)
+      SettingSingleton.__send__ method, *args
+    rescue NoMethodError
+      super
+    end
+  end
+end

data/lib/tinet/shell.rb

@@ -0,0 +1,36 @@
+require "open3"
+require "tinet/setting"
+
+module Tinet
+  module Shell
+    DummyStatus = Struct.new(:success) do |status|
+      def success?
+        success
+      end
+    end
+
+    def sudo(command)
+      sh "sudo #{command}"
+    end
+
+    def sh(command, dry_run: false, print: false, continue: false)
+      if dry_run || print
+        Tinet.logger.info command
+      else
+        Tinet.logger.debug command
+      end
+
+      return ['', '', DummyStatus.new(true)] if dry_run
+
+      stdout, stderr, status = Open3.capture3(command)
+
+      if !status.success? && !continue
+        Tinet.logger.error "Command '#{command}' failed:"
+        Tinet.logger.error "  #{stderr.chomp}" unless stderr.chomp.empty?
+        exit(status.to_i)
+      end
+
+      [stdout.chomp, stderr.chomp, status]
+    end
+  end
+end

data/lib/tinet/switch.rb

@@ -0,0 +1,53 @@
+module Tinet
+  class Switch
+    # @param switch_hash [Hash]
+    # @return [Tinet::Switch]
+    def self.parse(switch_hash)
+      name, interfaces = switch_hash['name'], switch_hash['interfaces']
+      raise InvalidYAMLError, "Switch name is missing" if name.nil? || name.empty?
+      raise InvalidYAMLError, "Switch interfaces must be array" unless interfaces.is_a?(Array)
+
+      interfaces = interfaces.map { |interface| Interfase.parse(interface) }
+      self.new(name, interfaces)
+    end
+
+    attr_reader :name, :interfaces
+
+    # @param name [String]
+    # @param interfaces [Array<Tinet::Switch::Interfase>]
+    def initialize(name, interfaces)
+      @name = name
+      @interfaces = interfaces
+      interfaces.each { |interface| interface.switch = self }
+    end
+
+    class Interfase
+      TYPES = %w(docker netns phys).freeze
+
+      # @param interface_hash [Hash]
+      # @return [Tinet::Switch::Interfase]
+      def self.parse(interface_hash)
+        name, type, args = interface_hash['name'], interface_hash['type'], interface_hash['args']
+        raise InvalidYAMLError, "Interfase name is missing" if name.nil? || name.empty?
+        raise InvalidTypeError, "Unknown interface type: #{type}" unless TYPES.include?(type)
+        self.new(name, type.to_sym, args)
+      end
+
+      attr_reader :name, :type, :args, :switch
+
+      # @param name [String]
+      # @param type [Symbol]
+      # @param args [String, nil]
+      def initialize(name, type, args)
+        @name = name
+        @type = type.to_sym
+        @args = args
+        @switch = nil
+      end
+
+      def switch=(switch)
+        @switch = switch
+      end
+    end
+  end
+end

data/lib/tinet/version.rb

@@ -0,0 +1,3 @@
+module Tinet
+  VERSION = "0.0.2".freeze
+end

data/spec.template.yml

@@ -0,0 +1,39 @@
+nodes:
+  - name: C0
+    type: docker # optional (default: docker)
+    image: slankdev/ubuntu:18.04
+    interfaces:
+      - { name: net0, type: direct, args: C1#net0 }
+      - { name: net1, type: bridge, args: B0 }
+      - { name: net2, type: veth  , args: peer0 }
+      - { name: net3, type: phys }
+    cmds:
+      - cmd: ip link set dev net0 up
+
+  - name: C1
+    type: netns # optional (default: docker)
+    interfaces:
+      - { name: net0, type: direct, args: C0#net0 }
+      - { name: net1, type: bridge, args: B0 }
+    cmds:
+      - cmd: echo slankdev slankdev
+      - cmd: >-
+          echo slankdev &&
+          echo slnakdev
+
+switches:
+  - name: B0
+    interfaces:
+      - { name: net0, type: docker, args: C0 }
+      - { name: net0, type: netns, args: C1 }
+
+test:
+  - name: p2p
+    cmds:
+    - cmd: docker exec C0 ping -c2 10.0.0.2
+    - cmd: echo slankdev slankdev
+
+  - name: lo
+    cmds:
+    - cmd: docker exec C0 ping -c2 10.255.0.1
+    - cmd: echo slankdev slankdev

data/tinet.gemspec

@@ -0,0 +1,32 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "tinet/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "tinet"
+  spec.version       = Tinet::VERSION
+  spec.authors       = ["koki-sato"]
+  spec.email         = ["admin@koki-sato.com"]
+
+  spec.summary       = "Ruby implement of slankdev/tinet."
+  spec.homepage      = "https://github.com/koki-sato/tinet-rb"
+  spec.license       = "MIT"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/koki-sato/tinet-rb"
+  spec.metadata["changelog_uri"] = "https://github.com/koki-sato/tinet-rb/blob/master/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|sample|features)/}) }
+  end
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "thor"
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: tinet
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- koki-sato
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-10-08 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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- admin@koki-sato.com
+executables:
+- tinet
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/tinet
+- lib/tinet.rb
+- lib/tinet/cli.rb
+- lib/tinet/command/base.rb
+- lib/tinet/command/build.rb
+- lib/tinet/command/conf.rb
+- lib/tinet/command/down.rb
+- lib/tinet/command/exec.rb
+- lib/tinet/command/init.rb
+- lib/tinet/command/ps.rb
+- lib/tinet/command/pull.rb
+- lib/tinet/command/up.rb
+- lib/tinet/data.rb
+- lib/tinet/link.rb
+- lib/tinet/node.rb
+- lib/tinet/setting.rb
+- lib/tinet/shell.rb
+- lib/tinet/switch.rb
+- lib/tinet/version.rb
+- spec.template.yml
+- tinet.gemspec
+homepage: https://github.com/koki-sato/tinet-rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/koki-sato/tinet-rb
+  source_code_uri: https://github.com/koki-sato/tinet-rb
+  changelog_uri: https://github.com/koki-sato/tinet-rb/blob/master/CHANGELOG.md
+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.7.6
+signing_key: 
+specification_version: 4
+summary: Ruby implement of slankdev/tinet.
+test_files: []