mybot 0.0.4 → 0.1.0

data/lib/mybot/installer.rb

@@ -0,0 +1,31 @@
+require "fileutils"
+
+module Mybot
+  module Installer
+    def install(options = {})
+      if File.exists? Mybot::MYBOT_PATH
+        error "mybot is already installed"
+      end
+
+      info "installing mybot to #{Mybot::MYBOT_PATH}"
+      FileUtils.mkdir Mybot::MYBOT_PATH
+      FileUtils.cp_r Mybot::VENDOR_PATH, Mybot::MYBOT_PATH
+      ["lib", "plugins", "tasks", "tpl"].each do |dir|
+        FileUtils.rm File.join(Mybot::MYBOT_PATH, dir, ".gitkeep")
+      end
+    end
+
+    def uninstall(options = {})
+      unless File.exists? Mybot::MYBOT_PATH
+        error "mybot is not installed"
+      end
+
+      info "uninstalling mybot"
+      if yes? "Do you really want to delete ~/.mybot? [y/n]: "
+        FileUtils.rm_rf Mybot::MYBOT_PATH
+      else
+        info "uninstallation aborted"
+      end
+    end
+  end
+end

data/lib/mybot/lib.rb

@@ -1,70 +1,31 @@
 module Mybot
   class Lib
-    include Messages
-    include Commands
-    include Utils
-
-    def method_missing(name, options = {}, &block)
-      lib_path = lib_to_path(self.class.to_s)
-
-      if name =~ /require\_([a-zA-Z_]*)installed/
-        base_name = $1.chomp "_"
-
-        methods = []
-
-        if base_name != ""
-          methods = [
-            "#{base_name}_installed?",
-            "#{base_name}_install",
-            "#{base_name}_reconfigure"
-          ]
-        else
-          methods = ["installed?", "install", "reconfigure"]
-        end
-
-        methods[0..-2].each do |m|
-          unless respond_to?(m)
-            error "lib '#{lib_path}' does not have method '#{m}'"
-          end
-        end
-
-        unless send(methods[0], options)
-          send(methods[1], options)
-        end
-
-        if respond_to?(methods[2])
-          send(methods[2], options)
-        end
-
-        return
-      elsif name =~ /require\_([a-zA-Z_]*)created/
-        base_name = $1.chomp "_"
+    def initialize(lib)
+      @lib = lib
+    end
 
-        methods = []
+    def method_missing(name, *args, &block)
+      unless @lib[:funcs][name]
+        error "func '#{@lib[:name]}'.'#{name}' is not defined"
+      end
 
-        if base_name != ""
-          methods = [
-            "#{base_name}_exists?",
-            "#{base_name}_create"
-          ]
-        else
-          methods = ["exists?", "create"]
-        end
+      if args[0].nil? || !args[0].is_a?(Node)
+        error "1st arg should be node in func '#{@lib[:name]}'.'#{name}'"
+      end
 
-        methods.each do |m|
-          unless respond_to?(m)
-            error "lib '#{lib_path}' does not have method '#{m}'"
-          end
-        end
+      if args[1].nil? || !args[1].is_a?(Hash)
+        error "2nd arg should be options in func '#{@lib[:name]}'.'#{name}'"
+      end
 
-        unless send(methods[0], options)
-          send(methods[1], options)
-        end
+      node = args[0]
+      options = args[1]
 
-        return
-      end
+      options[:sudo] ||= false
+      options[:cwd] ||= ""
+      options[:env] ||= {}
+      options.merge!(@lib[:options])
 
-      error "library '#{lib_path}' does not provide method #{name}"
+      return @lib[:funcs][name][:block].call(node, options)
     end
   end
 end

data/lib/mybot/libs.rb

@@ -1,41 +1,44 @@
 module Mybot
 	module Libs
-		def use(lib)
-      if lib.is_a?(Array)
-        lib.each do |l|
-          _use(l)
-        end
-      else
-        _use(lib)
-      end
-    end
+		def libs
+			@libs ||= {}
+		end
 
-    def _use(lib)
-      lib_name = lib.split("/").last
-      lib_file = File.join(LIB_PATH, "#{lib}.rb")
-
-      unless File.exists?(lib_file)
-        error "cannot load lib '#{lib_file}'"
+		def library(name, &block)
+      @library = name
+      unless libs[name]
+        libs[name] = {
+          :name => name,
+          :options => {},
+          :funcs => {}
+        }
       end
 
-      require lib_file
-      const = lib.split("/").map { |x| x.capitalize }.join("::")
-      klass = Kernel.qualified_const_get(const)
+      yield
+    ensure
+      @library = nil
+    end
 
-      if klass.instance_method(:initialize).arity == 1
-        @libs[lib_name.to_sym] ||= klass.new(self)
-      else
-        warning "#{lib_name.capitalize} library constructor should " +
-          "take one argument"
+    def library_options(options)
+      unless @library
+        error "library_options should be used only inside library definition"
       end
+      
+      libs[@library][:options].merge!(options)
     end
 
-    def method_missing(name, *args, &block)
-      if @libs[name.to_sym]
-        @libs[name.to_sym]
-      else
-        error "no such library loaded: #{name}"
+    def func(name, &block)
+      libs[@library][:funcs][name] = {
+        :block => block
+      }
+    end
+
+    def lib(name)
+      unless libs[name]
+        error "there is no lib '#{name}'"
       end
+
+      Lib.new libs[name]
     end
 	end
 end

data/lib/mybot/loader.rb

@@ -0,0 +1,25 @@
+module Mybot
+  module Loader
+    def load_files
+      ( Dir[File.join(MYBOT_PATH, "lib", "**", "*.rb")].flatten +
+        Dir[File.join(MYBOT_PATH, "plugins", "**", "lib", "**", "*.rb")].flatten +
+        Dir["Botfile"] +
+        Dir[File.join(".mybot", "**", "*.rb")].flatten +
+        Dir[File.join(MYBOT_PATH, "tasks", "**", "*.rb")].flatten +
+        Dir[File.join(MYBOT_PATH, "plugins", "**", "tasks", "**", "*.rb")].flatten +
+        Dir[File.join(GEM_PATH, "Botfile")]
+      ).reject do |f|
+        !File.exists?(f)
+      end.each do |f|
+        self.load_file(f)
+      end
+    end
+
+    def load_file(f)
+      instance_eval(File.read(f), __FILE__, __LINE__)
+    rescue Exception => e
+      warning "cannot load #{f}"
+      raise(e)
+    end
+  end
+end

data/lib/mybot/node.rb

@@ -3,107 +3,160 @@ require "net/sftp"
 
 module Mybot
   class Node
-    include Messages
-    include Libs
+    include Fmt
 
-    attr_accessor :host, :user, :options, :ssh, :sftp, :fmt
+    attr_accessor :host, :user, :options
 
     def initialize(host, user, options = {})
       @host, @user, @options = host, user, options
-      @fmt = Fmt.new(@host, @user)
-      @libs = {}
     end
 
     def ssh
-      @ssh ||= Net::SSH.start(@host, @user, @options)
+      @ssh ||= Net::SSH.start @host, @user, @options
     end
 
     def sftp
-      @sftp ||= Net::SFTP.start(@host, @user, @options)
+      @sftp ||= Net::SFTP.start @host, @user, @options
     end
 
-    def run(options, &block)
-      error "cmd not specified" unless options[:cmd]
+    def run(cmd, options = {}, &block)
+      error "cmd cannot be empty" if cmd == ""
 
-      command = Command.new(self)
+      start_time = Time.now
+      options[:sudo] ||= false
+      options[:cwd] ||= ""
+      options[:env] ||= {}
+
+      command = Command.new
       yield command if block_given?
-      
-      ssh.open_channel do |ch|
+
+      ssh.open_channel do |ch, ok|
         ch.request_pty do |ch, ok|
-          @fmt.error "cannot request pty" unless ok
+          error "cannot request pty" unless ok
         end
 
         command.channel = ch
 
-        inject_env(options)
+        run_info cmd, {
+          :host => @host,
+          :user => @user,
+          :sudo => options[:sudo],
+          :cwd => options[:cwd],
+          :env => options[:env]
+        }
 
         if options[:sudo]
-          options[:cmd] = "sudo #{options[:cmd]}"
-          command.handle_sudo
+          cmd = "sudo #{cmd}"
+          handle_sudo(command)
         end
 
-        prepend_cwd(options)
-        prepend_sources(options)
+        unless options[:env].empty?
+          values = options[:env].map { |k, v| "#{k}=#{v}" }.join " "
+          cmd = "#{values} #{cmd}"
+        end
 
-        @fmt.run(options[:cmd])
+        if options[:cwd] != ""
+          cmd = "cd #{options[:cwd]} && #{cmd}"
+        end
 
-        ch.exec options[:cmd] do |ch, ok|
-          @fmt.error "cannot exec #{options[:cmd]}" unless ok
+        ch.exec cmd do |ch, ok|
+          error "cannot exec '#{cmd}'" unless ok
 
           ch.on_data do |ch, data|
-            command.handle_stdout(data)
+            command.handle_stdout data
           end
 
           ch.on_extended_data do |ch, data|
-            command.handle_stderr(data)
+            command.handle_stderr data
           end
 
           ch.on_request("exit-status") do |ch, data|
-            command.result.exit_status = data.read_long
+            command.exit_status = data.read_long
           end
 
           ch.on_close do |ch|
-            #
+            command.time = Time.now - start_time
+            command.handle_close
           end
         end
       end
 
       ssh.loop
+
       return command.result
     end
 
-  private
-
-    def inject_env(options)
-      if options[:env]
-        env = []
-        options[:env].each do |k, v|
-          env << "#{k}='#{v}'"
+    def upload(file, options = {})
+      error "file '#{file}' does not exists" unless File.exists?(file)
+      error "to is required" unless options[:to]
+
+      start_time = Time.now
+      upload_info({
+        :host => @host,
+        :user => @user,
+        :file => file,
+        :to => options[:to]
+      })
+
+      sftp.upload!(file, options[:to]) do |event, uploader, *args|
+        case event
+        when :put
+          n = (args[1].to_f * 100 / args[0].size.to_f).to_i
+          progress(n)
+        when :finish
+          progress(100)
         end
-        options[:cmd] = "#{env.join(" ")} #{options[:cmd]}"
       end
+
+      time_info Time.now - start_time
     end
 
-    def prepend_cwd(options)
-      if options[:cwd]
-        options[:cmd] = "cd #{options[:cwd]} && #{options[:cmd]}"
+    def download(file, options = {})
+      error "to is required" unless options[:to]
+
+      start_time = Time.now
+      download_info({
+        :host => @host,
+        :user => @user,
+        :file => file,
+        :to => options[:to]
+      })
+
+      sftp.download!(file, options[:to]) do |event, uploader, *args|
+        case event
+        when :get
+          size = 0
+          if args[0].size
+            size = args[0].size
+          else
+            size = sftp.stat!(file).size
+          end
+          n = (args[1].to_f * 100 / size.to_f).to_i
+          progress(n)
+        when :finish
+          progress(100)
+        end
       end
+
+      time_info Time.now - start_time
     end
 
-    def prepend_sources(options)
-      sources = [
-        File.join("~", ".bashrc"),
-        File.join("~", ".bash_profile"),
-        File.join("~", ".profile")
-      ].map { |f| File.expand_path(f) }
+  private
 
-      sources.reject! { |f| !File.exists?(f) }
+    def handle_sudo(command)
+      @options[:password] ||= ""
+      
+      command.on "[sudo] password" do
+        command.write @options[:password], :shadow => true
+      end
 
-      prefix = sources.map do |s|
-        "source #{File.expand_path(s)}"
-      end.join(" && ")
+      command.on "Password:" do
+        command.write @options[:password], :shadow => true
+      end
 
-      options[:cmd] = "#{prefix} && #{options[:cmd]}"
+      command.on "Sorry, try again." do
+        error "cannot handle sudo automatically, try manually"
+      end
     end
   end
 end

data/lib/mybot/nodes.rb

@@ -0,0 +1,16 @@
+module Mybot
+	module Nodes
+		def node(host, user, options = {})
+      Node.new host, user, options
+    end
+
+    def run(*args, &block)
+      @nodes ||= []
+      error "no node specified" if @nodes.empty?
+
+      @nodes.each do |node|
+        node.run(*args, &block)
+      end
+    end
+	end
+end

data/lib/mybot/tasks.rb

@@ -1,11 +1,49 @@
 module Mybot
   module Tasks
-    include Messages
-
     def tasks
       @tasks ||= []
     end
 
+    def namespace(name)
+      outer_ns, @namespace = @namespace, name.to_s
+      if outer_ns && outer_ns != ""
+        @namespace = "#{outer_ns}:#{@namespace}"
+      end
+
+      yield
+    ensure
+      @namespace = outer_ns
+    end
+
+    def task(name, &block)
+      name, deps = *case name
+      when Hash
+        name.shift
+      else
+        [name, []]
+      end
+
+      deps = Array(deps).map do |d|
+        case d
+        when Symbol
+          "#{@namespace}:#{d}"
+        when String
+          d.include?(":") ? d : "#{@namespace}:#{d}"
+        end
+      end.uniq
+
+      task = tasks.find do |t|
+        t[:name] == name.to_s && t[:namespace] == @namespace
+      end
+
+      tasks.push({
+        :name => name.to_s,
+        :namespace => @namespace,
+        :deps => deps,
+        :block => block
+      }) unless task
+    end
+
     def find_task(name)
       ns = name.split ":"
       task = ns.pop
@@ -16,21 +54,19 @@ module Mybot
       end
     end
 
-    def run_task(name)
-      task_info name
+    def run_task(name, options)
       task = find_task(name)
 
-      unless task
-        warning "cannot find task '#{name}'"
-        find_task("mybot:tasks:list")[:block].call
-        abort
-      end
+      error "cannot find task '#{name}' " +
+        "use 'bot tasks:list' to see available tasks" unless task
+
+      task_info name
 
       task[:deps].each do |d|
-        run_task(d)
+        run_task(d, options)
       end
 
-      task[:block].call
+      task[:block].call(options)
     end
   end
 end