wakame-vdc-dcmgr 11.06.0 → 11.12.0

data/lib/dcmgr/drivers/iijgio_storage.rb

@@ -3,34 +3,24 @@
 module Dcmgr::Drivers
   
   class IIJGIOStorage < SnapshotStorage
-   
-    def download(keyname, filename, path) 
+    include Dcmgr::Logger
+    include Dcmgr::Helpers::SnapshotStorageHelper
+
+    def download(filename) 
       cmd = "get %s %s %s" 
-      args = [@bucket, keyname, File.join(path, filename)]
+      args = [@bucket, key(filename), self.snapshot(filename)]
       execute(cmd, args)
     end
 
-    def upload(keyname, file)
+    def upload(filename)
       cmd = "put %s %s %s"
-      args = [@bucket, keyname, file]
+      args = [@bucket, key(filename), self.snapshot(filename)]
       execute(cmd, args)
     end
 
-    def delete(keyname)
+    def delete(filename)
       cmd = "rm %s %s"
-      args = [@bucket, keyname]
-      execute(cmd, args)
-    end
-
-    def check(keyname)
-      cmd = "test %s %s"
-      args = [@bucket, keyname]
-      execute(cmd, args)
-    end
-    
-    def list
-      cmd = "ls %s"
-      args = [@bucket]
+      args = [@bucket, key(filename)]
       execute(cmd, args)
     end
   end

data/lib/dcmgr/drivers/iscsi_target.rb

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr
+  module Drivers
+    class IscsiTarget
+      attr_reader :node
+
+      def create(ctx)
+        raise NotImplmenetedError
+      end
+
+      def delete(ctx)
+        raise NotImplmenetedError
+      end
+
+      # Register target information to the target device.
+      # @param [Hash] volume hash data
+      def register(volume)
+        # TODO: uncomment here once all drivers were updated.
+        #raise NotImplmenetedError
+      end
+
+      def self.select_iscsi_target(iscsi_target, node)
+        raise ArgumentError unless node.is_a?(Isono::Node)
+        case iscsi_target
+        when "linux_iscsi"
+          bs = Dcmgr::Drivers::LinuxIscsi.new
+        when "sun_iscsi"
+          bs = Dcmgr::Drivers::SunIscsi.new
+        when "comstar"
+          bs = Dcmgr::Drivers::Comstar.new
+        else
+          raise "Unknown iscsi_target type: #{iscsi_target}"
+        end
+        # for bs.node readable accessor.
+        bs.instance_variable_set(:@node, node)
+        bs
+      end
+    end
+  end
+end

data/lib/dcmgr/drivers/kvm.rb

@@ -1,51 +1,105 @@
+# -*- coding: utf-8 -*-
+
+require 'net/telnet'
+
 module Dcmgr
   module Drivers
     class Kvm < Hypervisor
       include Dcmgr::Logger
       include Dcmgr::Helpers::CliHelper
-      include Dcmgr::Rpc::KvmHelper
       include Dcmgr::Helpers::NicHelper
 
+      # 0x0-2 are reserved by KVM.
+      # 0=Host bridge
+      # 1=ISA bridge
+      # 2=VGA
+      KVM_NIC_PCI_ADDR_OFFSET=0x10
+
       def run_instance(hc)
+
+        # tcp listen ports for KVM monitor and VNC console
+        monitor_port = pick_tcp_listen_port
+        vnc_port = pick_tcp_listen_port
+        File.open(File.expand_path('monitor.port', hc.inst_data_dir), "w") { |f|
+          f.write(monitor_port)
+        }
+        File.open(File.expand_path('vnc.port', hc.inst_data_dir), "w") { |f|
+          f.write(vnc_port)
+        }
+        
         # run vm
         inst = hc.inst
-        cmd = "kvm -m %d -smp %d -name vdc-%s -vnc :%d -drive file=%s -pidfile %s -daemonize -monitor telnet::%d,server,nowait"
-        args=[inst[:instance_spec][:memory_size],
-              inst[:instance_spec][:cpu_cores],
+        cmd = ["kvm -m %d -smp %d -name vdc-%s -vnc :%d",
+               "-cpu host",
+               "-pidfile %s",
+               "-daemonize",
+               "-monitor telnet:127.0.0.1:%d,server,nowait",
+               "-no-shutdown",
+               ]
+        args=[inst[:memory_size],
+              inst[:cpu_cores],
               inst[:uuid],
-              inst[:runtime_config][:vnc_port],
-              hc.os_devpath,
+              vnc_port - 5900, # KVM -vnc offsets 5900
               File.expand_path('kvm.pid', hc.inst_data_dir),
-              inst[:runtime_config][:telnet_port]
+              monitor_port
              ]
-        if vnic = inst[:instance_nics].first
-          cmd += " -net nic,macaddr=%s -net tap,ifname=%s,script=,downscript="
-          args << vnic[:mac_addr].unpack('A2'*6).join(':')
-          args << vnic[:uuid]
-        end
-        sh(cmd, args)
 
-        unless vnic.nil?
-          sh("/sbin/ifconfig %s 0.0.0.0 up", [vnic[:uuid]])
-          sh("/usr/sbin/brctl addif %s %s", [hc.bridge_if, vnic[:uuid]])
+        cmd << "-drive file=%s,media=disk,boot=on,index=0,cache=none,if=#{drive_model(hc)}"
+        args << hc.os_devpath
+        cmd << "-drive file=%s,media=disk,index=1,cache=none,if=#{drive_model(hc)}"
+        args << hc.metadata_img_path
+
+        vifs = inst[:vif]
+        if !vifs.empty?
+          vifs.sort {|a, b|  a[:device_index] <=> b[:device_index] }.each { |vif|
+            cmd << "-net nic,vlan=#{vif[:device_index].to_i},macaddr=%s,model=#{nic_model(hc)},addr=%x -net tap,vlan=#{vif[:device_index].to_i},ifname=%s,script=no,downscript=no"
+            args << vif[:mac_addr].unpack('A2'*6).join(':')
+            args << (KVM_NIC_PCI_ADDR_OFFSET + vif[:device_index].to_i)
+            args << vif[:uuid]
+          }
         end
+        sh(cmd.join(' '), args)
+
+        vifs.each { |vif|
+          if vif[:ipv4]
+            sh("/sbin/ip link set %s up", [vif[:uuid]])
+            sh("/usr/sbin/brctl addif %s %s", [vif[:ipv4][:network][:link_interface], vif[:uuid]])
+          end
+        }
 
         sleep 1
       end
 
       def terminate_instance(hc)
-        kvm_pid=`pgrep -u root -f vdc-#{hc.inst_id}`
-        if $?.exitstatus == 0 && kvm_pid.to_s =~ /^\d+$/
-          sh("/bin/kill #{kvm_pid}")
-        else
-          logger.error("Can not find the KVM process. Skipping: kvm -name vdc-#{hc.inst_id}")
+        begin
+          connect_monitor(hc) { |t|
+            t.cmd("quit")
+          }
+        rescue Errno::ECONNRESET => e
+          # succssfully terminated the process
+        rescue => e
+          kvm_pid = File.read(File.expand_path('kvm.pid', hc.inst_data_dir))
+          if kvm_pid.nil? || kvm_pid == ''
+            kvm_pid=`pgrep -u root -f vdc-#{hc.inst_id}`
+          end
+          if kvm_pid.to_s =~ /^\d+$/
+            sh("/bin/kill -9 #{kvm_pid}") rescue logger.error($!)
+          else
+            logger.error("Can not find the KVM process. Skipping: #{hc.inst_id}")
+          end
         end
       end
 
       def reboot_instance(hc)
         inst = hc.inst
-        connect_monitor(inst[:runtime_config][:telnet_port]) { |t|
+        connect_monitor(hc) { |t|
           t.cmd("system_reset")
+          # When the guest initiate halt/poweroff the KVM might become
+          # "paused" status. At that time, "system_reset" command does
+          # not work as it is an ACPI signal. The "cont" command allows
+          # to bring the status back to running in this case.
+          # It has no effect if the status is kept running already.
+          t.cmd('cont')
         }
       end
 
@@ -61,12 +115,12 @@ module Dcmgr
         inst = hc.inst
 
         sddev = File.expand_path(File.readlink(hc.os_devpath), '/dev/disk/by-path')
-        connect_monitor(inst[:runtime_config][:telnet_port]) { |t|
+        connect_monitor(hc) { |t|
           # success message:
           #   OK domain 0, bus 0, slot 4, function 0
           # error message:
           #   failed to add file=/dev/xxxx,if=virtio
-          c = t.cmd("pci_add auto storage file=#{sddev},if=scsi")
+          c = t.cmd("pci_add auto storage file=#{sddev},if=#{drive_model(hc)},cache=off")
           # Note: pci_parse_devaddr() called in "pci_add" uses strtoul()
           # with base 16 so that the input is expected in hex. however
           # at the result display, void pci_device_hot_add_print() uses
@@ -96,8 +150,9 @@ module Dcmgr
         vol = hc.vol
         pci_devaddr = vol[:guest_device_name]
 
-        connect_monitor(inst[:runtime_config][:telnet_port]) { |t|
+        connect_monitor(hc) { |t|
           t.cmd("pci_del #{pci_devaddr}")
+
           #
           #  Bus  0, device   4, function 0:
           #    SCSI controller: PCI device 1af4:1001
@@ -105,14 +160,92 @@ module Dcmgr
           #      BAR0: I/O at 0x1000 [0x103f].
           #      BAR1: 32 bit memory at 0x08000000 [0x08000fff].
           #      id ""
-          c = t.cmd("info pci")
           pci_devaddr = pci_devaddr.split(':')
-          unless c.split(/\n/).grep(/\s+Bus\s+#{pci_devaddr[1].to_i(16)}, device\s+#{pci_devaddr[2].to_i(16)}, function/).empty?
-            raise "Detached disk device still be attached in qemu-kvm: #{pci_devaddr.join(':')}"
+          pass=false
+          tryagain do
+            sleep 1
+            pass = t.shell_result("info pci").split(/\n/).grep(/\s+Bus\s+#{pci_devaddr[1].to_i(16)}, device\s+#{pci_devaddr[2].to_i(16)}, function/).empty?
           end
+          raise "Detached disk device still be attached in qemu-kvm: #{pci_devaddr.join(':')}" if pass == false
         }
       end
 
+      private
+      # Establish telnet connection to KVM monitor console
+      def connect_monitor(hc, &blk)
+        port = File.read(File.expand_path('monitor.port', hc.inst_data_dir)).to_i
+        logger.debug("monitor port number: #{port}")
+        begin
+          telnet = ::Net::Telnet.new("Host" => "localhost",
+                                     "Port"=>port.to_s,
+                                     "Prompt" => /\n\(qemu\) \z/,
+                                     "Timeout" => 60,
+                                     "Waittime" => 0.2)
+
+          # Add helper method for parsing response from qemu monitor shell.
+          telnet.instance_eval {
+            def shell_result(cmdstr)
+              ret = ""
+              hit = false
+              self.cmd(cmdstr).split("\n(qemu) ").each { |i|
+                i.split("\n").each { |i2|
+                  
+                  if i2 =~ /#{cmdstr}/
+                    hit = true
+                    next
+                  end
+                  ret += ("\n" + i2) if hit
+                }
+              }
+              ret.sub(/^\n/, '')
+            end
+          }
+          
+          blk.call(telnet)
+        ensure
+          telnet.close
+        end
+      end
+
+      TCP_PORT_MAX=65535
+      PORT_OFFSET=9000
+      # Randomly choose unused local tcp port number.
+      def pick_tcp_listen_port
+        # Support only for Linux netstat output.
+        l=`/bin/netstat -nlt`.split("\n")
+        # take out two header lines.
+        l.shift
+        l.shift
+
+        listen_ports = {}
+        
+        l.each { |n|
+          m = n.split(/\s+/)
+          if m[0] == 'tcp'
+            ip, port = m[3].split(':')
+            listen_ports[port.to_i]=ip
+          elsif m[0] == 'tcp6'
+            ary = m[3].split(':')
+            port = ary.pop
+            listen_ports[port.to_i]=ary.join(':')
+          end
+        }
+
+
+        begin
+          new_port = (PORT_OFFSET + rand(TCP_PORT_MAX - PORT_OFFSET))
+        end until(!listen_ports.has_key?(new_port))
+        new_port
+      end
+
+      def drive_model(hc)
+        hc.inst[:image][:features][:virtio] ? 'virtio' : 'scsi'
+      end
+
+      def nic_model(hc)
+        hc.inst[:image][:features][:virtio] ? 'virtio' : 'e1000'
+      end
+      
     end
   end
 end

data/lib/dcmgr/drivers/linux_iscsi.rb

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr
+  module Drivers
+    class LinuxIscsi < IscsiTarget
+      include Dcmgr::Logger
+      include Dcmgr::Helpers::CliHelper
+
+      IQN_PREFIX="iqn.2010-09.jp.wakame".freeze
+      
+      def create(ctx)
+        @volume    = ctx.volume
+        @volume_id = ctx.volume_id
+        @node      = ctx.node
+
+        vol_path = File.join(@volume[:storage_node][:export_path], @volume[:account_id], @volume[:uuid]) 
+        
+        @volume[:transport_information] = iscsi = {}
+        iscsi[:iqn] = "#{IQN_PREFIX}:#{@volume[:account_id]}.#{@volume[:uuid]}"
+        iscsi[:tid] = pick_next_tid
+        iscsi[:lun] = 1
+        iscsi[:backing_store] = vol_path
+
+        register(@volume)
+        
+        opt = { :iqn => iscsi[:iqn], :lun => iscsi[:lun], :tid => iscsi[:tid], :backing_store => iscsi[:backing_store] }
+      end
+
+      def delete(ctx)
+        @volume = ctx.volume
+        sh("/usr/sbin/tgt-admin --delete #{@volume[:transport_information][:iqn]}")
+      end
+
+      def register(volume)
+        tinfo = volume[:transport_information]
+
+        # register target
+        sh("/usr/sbin/tgtadm --lld iscsi --op new --mode=target --tid=%s --targetname %s", [tinfo[:tid], tinfo[:iqn]])
+        # register logical unit
+        sh("/usr/sbin/tgtadm --lld iscsi --op new --mode=logicalunit --tid=%s --lun=%s -b %s",
+           [tinfo[:tid], tinfo[:lun], tinfo[:backing_store]])
+        # bind target
+        sh("/usr/sbin/tgtadm --lld iscsi --op bind --mode=target --tid=%s --initiator-address=%s",
+           [tinfo[:tid], node.manifest.config.initiator_address])
+      end
+      
+      private
+      def pick_next_tid
+        # $ sudo /usr/sbin/tgtadm --lld iscsi --op show --mode target | grep '^Target '
+        # Target 1: iqn.2010-09.jp.wakame:a-shpoolxx.vol-dw55bba8
+        last_target = `/usr/sbin/tgtadm --lld iscsi --op show --mode target | grep ^Target`.split("\n").last
+        tid = if last_target.nil?
+                1
+              else
+                last_target.split(':').first.split(' ')[1].to_i + 1
+              end
+      end
+    end
+  end
+end

data/lib/dcmgr/drivers/local_storage.rb

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Drivers
+  class LocalStorage < SnapshotStorage
+    include Dcmgr::Logger
+    include Dcmgr::Helpers::CliHelper
+
+    def download(filename)
+      from = File.join(@volume_snaphost_path, filename)
+      to   = self.snapshot(filename)
+
+      logger.debug("copying #{from} to #{to}")
+      sh("/bin/cp -p %s %s", [from, to])
+    end
+
+    def upload(filename)
+      sh("/bin/mv %s %s", [self.snapshot(filename), File.join(@volume_snaphost_path, filename)])
+    end
+
+    def delete(filename)
+      sh("rm -f %s", [File.join(@volume_snaphost_path, filename)])
+    end
+  end
+end

data/lib/dcmgr/drivers/lxc.rb

@@ -1,165 +1,207 @@
+# -*- coding: utf-8 -*-
+
+require 'erb'
+
 module Dcmgr
   module Drivers
     class Lxc < Hypervisor
       include Dcmgr::Logger
       include Dcmgr::Helpers::CliHelper
 
-      def create_config
-        # create config file i-xxxxxxxx.log
-        inst_id = @inst[:uuid]
-        vnic = @inst[:instance_nics].first
-        mac_addr = vnic[:mac_addr].unpack('A2'*6).join(':')
-        
-        config_name = "#{@inst_data_dir}/config.#{inst_id}"
-        # check config file
-        if File.exist?(config_name)
-          sh("rm #{config_name}")
-        end
-
-        config = File.open(config_name, 'w')
-        config.puts "lxc.utsname = #{inst_id}"
-        config.puts "lxc.tty = 4"
-        config.puts "lxc.pts = 1024"
-        config.puts "lxc.network.type = veth"
-        config.puts "lxc.network.veth.pair = #{vnic[:uuid]}"
-        config.puts "lxc.network.flags = up"
-        config.puts "lxc.network.link = #{@bridge_if}"
-        config.puts "lxc.network.hwaddr = #{mac_addr}"
-        config.puts "lxc.rootfs = #{@inst_data_dir}/rootfs"
-        config.puts "lxc.mount = #{@inst_data_dir}/fstab"
-        config.puts "lxc.cgroup.devices.deny = a"
-        config.puts "lxc.cgroup.devices.allow = c 1:3 rwm"
-        config.puts "lxc.cgroup.devices.allow = c 1:5 rwm"
-        config.puts "lxc.cgroup.devices.allow = c 5:1 rwm"
-        config.puts "lxc.cgroup.devices.allow = c 5:0 rwm"
-        config.puts "lxc.cgroup.devices.allow = c 4:0 rwm"
-        config.puts "lxc.cgroup.devices.allow = c 4:1 rwm"
-        config.puts "lxc.cgroup.devices.allow = c 1:9 rwm"
-        config.puts "lxc.cgroup.devices.allow = c 1:8 rwm"
-        config.puts "lxc.cgroup.devices.allow = c 136:* rwm"
-        config.puts "lxc.cgroup.devices.allow = c 5:2 rwm"
-        config.puts "lxc.cgroup.devices.allow = c 254:0 rwm"
-        config.puts "lxc.cgroup.devices.allow = c 10:232 rwm"
-        config.puts "lxc.cgroup.devices.allow = c 10:200 rwm"
-        unless @inst[:volume].nil?
-          @inst[:volume].each { |volid, v|
-            vol_id = volid
-            vol = v
-            unless v[:guest_device_name].nil?
-              config.puts "lxc.cgroup.devices.allow = b #{v[:guest_device_name]} rwm"
-            else
-              @os_devpath = v[:host_device_name] unless v[:host_device_name].nil?
-              sddev = File.expand_path(File.readlink(@os_devpath), '/dev/disk/by-path')
-              # find major number and minor number to device file
-              stat = File.stat(sddev)
-              config.puts "lxc.cgroup.devices.allow = b #{stat.rdev_major}:#{stat.rdev_minor} rwm"
-            end
-          }
-        end
-        config.close
-        config_name
-      end
-
-      def create_fstab
-        config_name = "#{@inst_data_dir}/fstab"
-        config = File.open(config_name, "w")
-        config.puts "proc #{@inst_data_dir}/rootfs/proc proc nodev,noexec,nosuid 0 0"
-        config.puts "devpts #{@inst_data_dir}/rootfs/dev/pts devpts defaults 0 0"
-        config.puts "sysfs #{@inst_data_dir}/rootfs/sys sysfs defaults 0 0"
-        config.close
-      end
-
-      def setup_container
-        sh("echo \"127.0.0.1 localhost #{@inst_id}\" > #{@inst_data_dir}/rootfs/etc/hosts")
-        sh("echo \"#{@inst_id}\" > #{@inst_data_dir}/rootfs/etc/hostname")
-      end
-
-      def run_instance(hc)
+      def run_instance(ctx)
         # run lxc
-        @inst = hc.inst
-        @bridge_if = hc.bridge_if
-        @inst_data_dir = hc.inst_data_dir
-        @os_devpath = hc.os_devpath
+        @os_devpath = ctx.os_devpath
         if @os_devpath.nil?
-          if @inst[:image][:boot_dev_type] == 1
-            @inst[:volume].each{|volid, v|
-              @os_devpath = v[:host_device_name] if v[:boot_dev] == 1
+          if ctx.inst[:image][:boot_dev_type] == 1
+            ctx.inst[:volume].each{ |vol_id, vol|
+              @os_devpath = vol[:host_device_name] if vol[:boot_dev] == 1
             }
           else
-            @os_devpath = "#{@inst_data_dir}/#{hc.inst_id}"
+            @os_devpath = "#{ctx.inst_data_dir}/#{ctx.inst_id}"
           end
         end
         # check mount point
-        mount_point = "#{@inst_data_dir}/rootfs"
-        unless File.exist?(mount_point)
-          sh("mkdir #{mount_point}")
-        end
+        mount_point = "#{ctx.inst_data_dir}/rootfs"
+        Dir.mkdir(mount_point) unless File.exists?(mount_point)
 
         cmd = "mount %s %s"
         args = [@os_devpath, mount_point]
-        if @inst[:image][:boot_dev_type] == 2
+        if ctx.inst[:image][:boot_dev_type] == 2
           cmd += " -o loop"
         end
         sh(cmd, args)
 
-        config_name = create_config
-        create_fstab
-        setup_container
-
-        sh("lxc-create -f %s -n %s", [config_name, @inst[:uuid]])
-        sh("sudo lxc-start -n %s -d -l DEBUG -o %s/%s.log", [@inst[:uuid], @inst_data_dir, @inst[:uuid]])
+        # metadata drive
+        metadata_path = "#{ctx.inst_data_dir}/rootfs/metadata"
+        Dir.mkdir(metadata_path) unless File.exists?(metadata_path)
+        sh("mount -t vfat -o loop -o ro #{ctx.metadata_img_path} #{metadata_path}")
+
+        config_path = create_config(ctx)
+        create_fstab(ctx)
+        setup_container(ctx)
+        mount_cgroup
+
+        # Ubuntu 10.04.3 LTS
+        # Linux ubuntu 2.6.38-10-generic #46~lucid1-Ubuntu SMP Wed Jul 6 18:40:11 UTC 2011 i686 GNU/Linux
+        # Linux ubuntu 2.6.38-8-server #42-Ubuntu SMP Mon Apr 11 03:49:04 UTC 2011 x86_64 GNU/Linux
+        # lxc 0.7.4-0ubuntu7
+        #
+        # Ubuntu-10.04.3 on Virtualbox-4.0.12 r72916 on Windows-7
+        # Ubuntu-10.10
+        #
+        # > lxc-start 1311803515.629 ERROR    lxc_start - inherited fd 3 on pipe:[58281]
+        # > lxc-start 1311803515.629 ERROR    lxc_start - inherited fd 4 on pipe:[58281]
+        # > lxc-start 1311803515.629 ERROR    lxc_start - inherited fd 6 on socket:[58286]
+        #
+        # http://comments.gmane.org/gmane.linux.kernel.containers.lxc.general/912
+        # http://comments.gmane.org/gmane.linux.kernel.containers.lxc.general/1400
+        lxc_version = `lxc-version`.chomp.split(': ').last
+        logger.debug("lxc-version: #{lxc_version}")
+
+        sh("lxc-create -f %s -n %s", [config_path, ctx.inst[:uuid]])
+        sh("lxc-start -n %s -d -l DEBUG -o %s/%s.log 3<&- 4<&- 6<&-", [ctx.inst[:uuid], ctx.inst_data_dir, ctx.inst[:uuid]])
       end
 
-      def terminate_instance(hc)
-        sh("lxc-stop -n #{hc.inst_id}")
-        sh("lxc-destroy -n #{hc.inst_id}")
-        sh("umount #{hc.inst_data_dir}/rootfs")
+      def terminate_instance(ctx)
+        sh("lxc-stop -n #{ctx.inst_id}")
+        sh("lxc-destroy -n #{ctx.inst_id}")
+        sh("umount #{ctx.inst_data_dir}/rootfs/metadata")
+        sh("umount #{ctx.inst_data_dir}/rootfs")
       end
 
-      def reboot_instance(hc)
-        inst = hc.inst
-        terminate_instance(hc)
-        run_instance(hc)
+      def reboot_instance(ctx)
+        sh("lxc-stop -n #{ctx.inst[:uuid]}")
+        sh("lxc-start -n %s -d -l DEBUG -o %s/%s.log 3<&- 4<&- 6<&-", [ctx.inst[:uuid], ctx.inst_data_dir, ctx.inst[:uuid]])
       end
 
-      def attach_volume_to_guest(hc)
-        inst_id = hc.inst_id
-        sddev = File.expand_path(File.readlink(hc.os_devpath), '/dev/disk/by-path')
+      def attach_volume_to_guest(ctx)
+        sddev = File.expand_path(File.readlink(ctx.os_devpath), '/dev/disk/by-path')
 
         # find major number and minor number to device file
         stat = File.stat(sddev)
         devnum = [stat.rdev_major,stat.rdev_minor].join(':')
-        
-        sh("echo \"b #{devnum} rwm\" > /cgroup/#{inst_id}/devices.allow")
-        sh("mknod #{hc.inst_data_dir}/rootfs#{sddev} -m 660 b #{stat.rdev_major} #{stat.rdev_minor}")
-
-        config_name = "#{hc.inst_data_dir}/config.#{inst_id}"
-        config = File.open(config_name, 'r')
-        data = config.readlines
-        config.close
-        config = File.open(config_name, 'w')
-        config.write data
-        config.puts "lxc.cgroup.devices.allow = b #{devnum} rwm"
-        config.close
+
+        sh("echo \"b #{devnum} rwm\" > /cgroup/#{ctx.inst_id}/devices.allow")
+        logger.debug("Makinging new block device: #{ctx.inst_data_dir}/rootfs#{sddev}")
+        sh("mknod #{ctx.inst_data_dir}/rootfs#{sddev} -m 660 b #{stat.rdev_major} #{stat.rdev_minor}")
+
+        config_path = "#{ctx.inst_data_dir}/config.#{ctx.inst_id}"
+        File.open(config_path, 'a+') { |f|
+          f.puts "lxc.cgroup.devices.allow = b #{devnum} rwm"
+        }
+
         devnum
       end
 
-      def detach_volume_from_guest(hc)
-        inst_id = hc.inst_id
-        vol = hc.vol
+      def detach_volume_from_guest(ctx)
+        vol = ctx.vol
         sddev = File.expand_path(File.readlink(vol[:host_device_name]), '/dev/disk/by-path')
         devnum = vol[:guest_device_name]
 
-        sh("echo \"b #{devnum} rwm\" > /cgroup/#{inst_id}/devices.deny")
-        sh("rm -rf #{hc.inst_data_dir}/rootfs#{sddev}")
+        sh("echo \"b #{devnum} rwm\" > /cgroup/#{ctx.inst_id}/devices.deny")
+        logger.debug("Deleting block device: #{ctx.inst_data_dir}/rootfs#{sddev}")
+        sh("rm #{ctx.inst_data_dir}/rootfs#{sddev}")
+
+        config_path = "#{ctx.inst_data_dir}/config.#{ctx.inst_id}"
+        config_body = File.open(config_path, 'r') { |f|
+          f.readlines.select {|line| line != "lxc.cgroup.devices.allow = b #{devnum} rwm\n" }
+        }
+        File.open(config_path, 'w') { |f|
+          f.write config_body
+        }
+      end
+
+      private
+      def create_config(ctx)
+        # create config file i-xxxxxxxx.log
+
+        config_path = "#{ctx.inst_data_dir}/config.#{ctx.inst_id}"
+        # check config file
+        if File.exist?(config_path)
+          sh("rm #{config_path}")
+        end
+
+        vifs = ctx.inst[:vif]
+
+        File.open(config_path, 'w') { |f|
+          f.puts "lxc.utsname = #{ctx.inst_id}"
+          f.puts ""
+          if !vifs.empty?
+            vifs.sort {|a, b|  a[:device_index] <=> b[:device_index] }.each { |vif|
+              f.puts "lxc.network.type = veth"
+              if vif[:ipv4]
+                f.puts "lxc.network.link = #{vif[:ipv4][:network][:link_interface]}"
+              end
+              f.puts "lxc.network.veth.pair = #{vif[:uuid]}"
+              f.puts "lxc.network.hwaddr = #{vif[:mac_addr].unpack('A2'*6).join(':')}"
+              f.puts "lxc.network.flags = up"
+            }
+          end
+          f.puts ""
+          f.puts "lxc.tty = 4"
+          f.puts "lxc.pts = 1024"
+          f.puts "lxc.rootfs = #{ctx.inst_data_dir}/rootfs"
+          f.puts "lxc.mount = #{ctx.inst_data_dir}/fstab"
+          f.puts ""
+          f.puts "lxc.cgroup.devices.deny = a"
+          f.puts "# /dev/null and zero"
+          f.puts "lxc.cgroup.devices.allow = c 1:3 rwm"
+          f.puts "lxc.cgroup.devices.allow = c 1:5 rwm"
+          f.puts "# consoles"
+          f.puts "lxc.cgroup.devices.allow = c 5:1 rwm"
+          f.puts "lxc.cgroup.devices.allow = c 5:0 rwm"
+          f.puts "lxc.cgroup.devices.allow = c 4:0 rwm"
+          f.puts "lxc.cgroup.devices.allow = c 4:1 rwm"
+          f.puts "# /dev/{,u}random"
+          f.puts "lxc.cgroup.devices.allow = c 1:9 rwm"
+          f.puts "lxc.cgroup.devices.allow = c 1:8 rwm"
+          f.puts "lxc.cgroup.devices.allow = c 136:* rwm"
+          f.puts "lxc.cgroup.devices.allow = c 5:2 rwm"
+          f.puts "#rtc"
+          f.puts "lxc.cgroup.devices.allow = c 254:0 rwm"
+          f.puts "#kvm"
+          f.puts "#lxc.cgroup.devices.allow = c 10:232 rwm"
+          f.puts "#lxc.cgroup.devices.allow = c 10:200 rwm"
+
+          unless ctx.inst[:volume].nil?
+            ctx.inst[:volume].each { |vol_id, vol|
+              unless vol[:guest_device_name].nil?
+                f.puts "lxc.cgroup.devices.allow = b #{vol[:guest_device_name]} rwm"
+              else
+                @os_devpath = vol[:host_device_name] unless vol[:host_device_name].nil?
+                sddev = File.expand_path(File.readlink(@os_devpath), '/dev/disk/by-path')
+                # find major number and minor number to device file
+                stat = File.stat(sddev)
+                f.puts "lxc.cgroup.devices.allow = b #{stat.rdev_major}:#{stat.rdev_minor} rwm"
+              end
+            }
+          end
+        }
 
-        config_name = "#{hc.inst_data_dir}/config.#{inst_id}"
-        config = File.open(config_name, 'r')
-        data = config.readlines.select {|f| f != "lxc.cgroup.devices.allow = b #{devnum} rwm\n" }
-        config.close
-        config = File.open(config_name, 'w+')
-        config.write data
-        config.close
+        config_path
+      end
+
+      def create_fstab(ctx)
+        config_path = "#{ctx.inst_data_dir}/fstab"
+        File.open(config_path, "w") { |f|
+          f.puts "proc   #{ctx.inst_data_dir}/rootfs/proc proc nodev,noexec,nosuid 0 0"
+          f.puts "devpts #{ctx.inst_data_dir}/rootfs/dev/pts devpts defaults 0 0"
+          f.puts "sysfs  #{ctx.inst_data_dir}/rootfs/sys sysfs defaults 0 0"
+        }
+      end
+
+      def setup_container(ctx)
+        sh("echo \"127.0.0.1 localhost #{ctx.inst_id}\" > #{ctx.inst_data_dir}/rootfs/etc/hosts")
+        sh("echo \"#{ctx.inst_id}\" > #{ctx.inst_data_dir}/rootfs/etc/hostname")
+      end
+
+      def mount_cgroup
+        `mount -t cgroup | egrep -q cgroup`
+        if $?.exitstatus != 0
+          mount_point = "/cgroup"
+          Dir.mkdir(mount_point) unless File.exists?(mount_point)
+          sh("mount none -t cgroup #{mount_point}")
+        end
       end
 
     end