mybot 0.0.1 → 0.0.2

data/lib/mybot/commands.rb

@@ -56,7 +56,7 @@ module Mybot
 
     def tpl_file(file)
       tpl = File.join(TPL_PATH, file)
-      fatal "template file '#{tpl}' does not exists" unless File.exists?(tpl)
+      error "template file '#{tpl}' does not exists" unless File.exists?(tpl)
       Template.new(File.read(tpl))
     end
 
@@ -65,15 +65,15 @@ module Mybot
       $stdin.gets
     end
 
-    def ask(q)
-      $stdout.print "#{q}?: "
+    def ask(q = "")
+      $stdout.print "#{q}"
       $stdin.gets.chomp
     end
 
-    def yes?(q)
+    def yes?(q = "")
       result = ""
       loop do
-        $stdout.print "#{q} (y/n)?: "
+        $stdout.print "#{q}"
         result = $stdin.gets.chomp
         break if result =~ /y|yes|Y|YES|Yes|n|no|N|NO|No/
       end

data/lib/mybot/core-ext/kernel.rb

@@ -0,0 +1,21 @@
+module Kernel
+	def qualified_const_get(str)
+    path = str.to_s.split('::')
+    from_root = path[0].empty?
+    if from_root
+      from_root = []
+      path = path[1..-1]
+    else
+      start_ns = ((Class === self) || (Module === self)) ? self : self.class
+      from_root = start_ns.to_s.split('::')
+    end
+    until from_root.empty?
+      begin
+        return (from_root+path).inject(Object) { |ns,name| ns.const_get(name) }
+      rescue NameError
+        from_root.delete_at(-1)
+      end
+    end
+    path.inject(Object) { |ns,name| ns.const_get(name) }
+  end
+end

data/lib/mybot/fmt.rb

@@ -33,10 +33,10 @@ module Mybot
     def write(data)
       write_format = "WRITE"
       write_format = write_format.blue.bold if @use_color
-      enter_format = "<ENTER>"
-      enter_format = enter_format.red.bold if @use_color
+      lf_format = "<LF>"
+      lf_format = lf_format.red.bold if @use_color
       if @show_stdin
-        $stdout.print "#{prompt} #{write_format} #{data}#{enter_format}\n"
+        $stdout.print "\n#{prompt} #{write_format} #{data}#{lf_format}\n"
       end
     end
 
@@ -70,10 +70,6 @@ module Mybot
       error_format = "ERROR"
       error_format = error_format.bold.red if @use_color
       $stdout.print "#{prompt} #{error_format} #{msg}\n"
-    end
-
-    def fatal(msg)
-      error(msg)
       abort
     end
 

data/lib/mybot/lib.rb

@@ -0,0 +1,9 @@
+module Mybot
+	class Lib
+		include Messages
+		include Commands
+		def method_missing(name, *args, &block)
+			error "library '#{self.class}' does not provide method #{name}"
+		end
+	end
+end

data/lib/mybot/messages.rb

@@ -1,20 +1,26 @@
+require "colored"
+
 module Mybot
   module Messages
     def info(msg)
-      puts "info: #{msg}"
+      info_format = "INFO".blue.bold
+      puts "#{info_format} #{msg}"
     end
 
     def warning(msg)
-      puts "warning: #{msg}"
+      warning_format = "WARNING".magenta.bold
+      puts "#{warning_format} #{msg}"
     end
 
     def error(msg)
-      puts "error: #{msg}"
+      error_format = "ERROR".red.bold
+      puts "#{error_format} #{msg}"
+      abort
     end
 
-    def fatal(msg)
-      puts "fatal: #{msg}"
-      abort
+    def task_info(name)
+      task_format = "TASK".green.bold
+      puts "#{task_format} #{name}"
     end
   end
 end

data/lib/mybot/node.rb

@@ -3,11 +3,13 @@ require "net/sftp"
 
 module Mybot
   class Node
-    attr_accessor :host, :user, :ssh, :sftp, :fmt
+    include Messages
+    attr_accessor :host, :user, :options, :ssh, :sftp, :fmt
 
     def initialize(host, user, options = {})
       @host, @user, @options = host, user, options
       @fmt = Fmt.new(@host, @user)
+      @libs = {}
     end
 
     def ssh
@@ -18,22 +20,78 @@ module Mybot
       @sftp ||= Net::SFTP.start(@host, @user, @options)
     end
 
+    def use(lib)
+      if lib.is_a?(Array)
+        lib.each do |l|
+          _use(l)
+        end
+      else
+        _use(lib)
+      end
+    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}'"
+      end
+
+      require lib_file
+      const = lib.split("/").map { |x| x.capitalize }.join("::")
+      klass = Kernel.qualified_const_get(const)
+
+      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"
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      if @libs[name.to_sym]
+        @libs[name.to_sym]
+      else
+        error "no such library loaded: #{name}"
+      end
+    end
+
     def run(options, &block)
-      @fmt.fatal "cmd not specified" unless options[:cmd]
+      error "cmd not specified" unless options[:cmd]
 
       command = Command.new(self)
       yield command if block_given?
 
       ssh.open_channel do |ch|
         ch.request_pty do |ch, ok|
-          @fmt.fatal "cannot request pty" unless ok
+          @fmt.error "cannot request pty" unless ok
         end
 
         command.channel = ch
+
+        if options[:env]
+          env = []
+          options[:env].each do |k, v|
+            env << "#{k}='#{v}'"
+          end
+          options[:cmd] = "#{env.join(" ")} #{options[:cmd]}"
+        end
+
+        if options[:sudo]
+          options[:cmd] = "sudo #{options[:cmd]}"
+          command.handle_sudo
+        end
+
+        if options[:cwd]
+          options[:cmd] = "cd #{options[:cwd]} && #{options[:cmd]}"
+        end
+
         @fmt.run(options[:cmd])
 
         ch.exec options[:cmd] do |ch, ok|
-          @fmt.fatal "run: cannot exec #{options[:cmd]}" unless ok
+          @fmt.error "run: cannot exec #{options[:cmd]}" unless ok
 
           ch.on_data do |ch, data|
             command.handle_stdout(data)
@@ -56,69 +114,5 @@ module Mybot
       ssh.loop
       return command.stdout_all
     end
-
-    def exists?(options)
-      @fmt.fatal "exists?: file not specified" unless options[:file]
-      
-      options[:cmd] = "test -e #{options[:file]} && echo EXISTS"
-      run(options).include?("EXISTS") ? true : false
-    end
-
-    def create(options)
-      @fmt.fatal "create: file not specified" unless options[:file]
-      
-      options[:cmd] = "mktemp /tmp/mybot.XXXXX"
-      tmp = run(options)
-
-      options[:content] ||= ""
-      sftp.file.open(tmp, "w") { |f| f.write options[:content] }
-      options[:cmd] = "mv #{tmp} #{options[:file]}"
-      run(options)
-    end
-
-    def read(options)
-      @fmt.fatal "read: file not specified" unless options[:file]
-
-      options[:cmd] = "cat #{options[:file]}"
-      run(options) do |cmd|
-        cmd.on "No such file or directory" do
-          @fmt.error "read: file '#{options[:file]}' does not exists"
-          return ""
-        end
-      end
-    end
-
-    def upload(options)
-      @fmt.fatal "upload: from not specified" unless options[:from]
-      @fmt.fatal "upload: to not specified" unless options[:to]
-      @fmt.upload(options[:from], options[:to])
-
-      sftp.upload!(options[:from], options[:to]) do |event, uploader, *args|
-        case event
-        when :put
-          n = (args[1].to_f * 100 / args[0].size.to_f).to_i
-          @fmt.progress(n)
-        when :finish
-          @fmt.progress(100)
-        end
-      end
-    end
-
-    def download(options)
-      @fmt.fatal "download: from not specified" unless options[:from]
-      @fmt.fatal "download: to not specified" unless options[:to]
-      @fmt.download(options[:from], options[:to])
-
-      sftp.download!(options[:from], options[:to]) do |event, uploader, *args|
-        case event
-        when :get
-          size = args[0].size ? args[0].size : sftp.stat!(options[:from]).size
-          n = (args[1].to_f * 100 / size.to_f).to_i
-          @fmt.progress(n)
-        when :finish
-          @fmt.progress(100)
-        end
-      end
-    end
   end
 end

data/lib/mybot/recipes.rb

@@ -1,9 +1,11 @@
 module Mybot
   module Recipes
+    include Messages
+
     def recipes
       @recipes ||= (
         Dir[File.join(GEM_PATH, "Botfile")] +
-        Dir[File.join(MYBOT_PATH, "tasks", "**", "*.rb")].flatten +
+        Dir[File.join(MYBOT_PATH, "recipes", "**", "*.rb")].flatten +
         Dir[File.join(".mybot", "**", "*.rb")].flatten +
         Dir["Botfile"]
       ).reject { |f| !File.exists?(f) }
@@ -16,7 +18,7 @@ module Mybot
     def load_recipe(r)
       instance_eval(File.read(r), __FILE__, __LINE__)
     rescue Exception => e
-      puts "error: cannot load recipe #{r}"
+      warning "cannot load recipe #{r}"
       raise(e)
     end
   end

data/lib/mybot/tasks.rb

@@ -17,10 +17,11 @@ module Mybot
     end
 
     def run_task(name)
+      task_info name
       task = find_task(name)
 
       unless task
-        error "cannot find task '#{name}'"
+        warning "cannot find task '#{name}'"
         find_task("mybot:tasks:list")[:block].call
         abort
       end

data/lib/mybot/version.rb

@@ -1,3 +1,3 @@
 module Mybot
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/mybot.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Sebastian Sito"]
   spec.email         = ["sebastian@hypenode.com"]
   spec.description   = %q{Provision, manage and monitor stuff}
-  spec.summary       = %q{Mybot, your personal bot}
+  spec.summary       = %q{mybot, my personal bot}
   spec.homepage      = "https://github.com/sebastiansito/mybot"
   spec.license       = "MIT"
 

data/vendor/lib/core/fs.rb

@@ -0,0 +1,185 @@
+module Core
+  class Fs < Mybot::Lib
+    def initialize(node)
+      @node = node
+    end
+
+    def exists?(options = {})
+      unless options[:file] || options[:dir]
+        error "file or dir is required"
+      end
+      
+      if options[:file]
+        options[:cmd] = "test -e #{options[:file]} && echo EXISTS"
+      elsif options[:dir]
+        options[:cmd] = "test -e #{options[:dir]} && echo EXISTS"
+      end
+      @node.run(options).include?("EXISTS") ? true : false
+    end
+
+    def create(options = {})
+      unless options[:file] || options[:dir]
+        error "file or dir is required"
+      end
+
+      if options[:file]
+        options[:cmd] = "mktemp /tmp/mybot.XXXXX"
+        
+        # do not use sudo when creating tmp file to be able to move file
+        sudo = options[:sudo]
+        options[:sudo] = false
+        tmp = @node.run(options)
+        options[:sudo] = sudo
+
+        options[:content] ||= ""
+        @node.sftp.file.open(tmp, "w") { |f| f.write options[:content] }
+        options[:cmd] = "mv #{tmp} #{options[:file]}"
+        @node.run(options)
+      else
+        options[:cmd] = "mkdir -p #{options[:dir]}"
+        @node.run(options)
+      end
+    end
+
+    def remove(options = {})
+      unless options[:file] || options[:dir]
+        error "file or dir is required"
+      end
+
+      if options[:file]
+        options[:cmd] = "rm -f #{options[:file]}"
+      else
+        options[:cmd] = "rm -rf #{options[:dir]}"
+      end
+
+      @node.run(options)
+    end
+
+    def read(options = {})
+      error "file is required" unless options[:file]
+
+      options[:cmd] = "cat #{options[:file]}"
+      @node.run(options) do |cmd|
+        cmd.on "No such file or directory" do
+          @node.fmt.error "read: file '#{options[:file]}' does not exists"
+          return ""
+        end
+      end
+    end
+
+    def upload(options = {})
+      error "from is required" unless options[:from]
+      error "to is required" unless options[:to]
+      @node.fmt.upload(options[:from], options[:to])
+
+      @node.sftp.upload!(options[:from],
+        options[:to]) do |event, uploader, *args|
+        case event
+        when :put
+          n = (args[1].to_f * 100 / args[0].size.to_f).to_i
+          @node.fmt.progress(n)
+        when :finish
+          @node.fmt.progress(100)
+        end
+      end
+    end
+
+    def download(options = {})
+      error "from is required" unless options[:from]
+      error "to is required" unless options[:to]
+      @node.fmt.download(options[:from], options[:to])
+
+      @node.sftp.download!(options[:from],
+        options[:to]) do |event, uploader, *args|
+        case event
+        when :get
+          size = 0
+          if args[0].size
+            size = args[0].size
+          else
+            size = @node.sftp.stat!(options[:from]).size
+          end
+          n = (args[1].to_f * 100 / size.to_f).to_i
+          @node.fmt.progress(n)
+        when :finish
+          @node.fmt.progress(100)
+        end
+      end
+    end
+
+    def compress(options = {})
+      error "from is required" unless options[:from]
+      error "to is required" unless options[:to]
+
+      options[:compressor] ||= "gz"
+
+      unless ["gz", "bzip2"].include?(options[:compressor])
+        error "invalid compressor"
+      end
+
+      options[:cmd] = "tar c"
+
+      if options[:compressor] == "gz"
+        options[:cmd] += "z"
+      elsif options[:compressor] == "bzip2"
+        options[:cmd] += "j"
+      end
+
+      from = options[:from].split("/")
+      from_name = from.pop
+      from_path = from.join("/")
+
+      options[:cmd] += "f #{options[:to]} #{from_name}"
+      options[:cwd] = from_path
+      @node.run(options)
+    end
+
+    def extract(options = {})
+      error "from is required" unless options[:from]
+      error "to is required" unless options[:to]
+
+      options[:compressor] ||= "gz"
+
+      unless ["gz", "bzip2"].include?(options[:compressor])
+        error "invalid compressor"
+      end
+
+      options[:cmd] = "tar x"
+
+      if options[:compressor] == "gz"
+        options[:cmd] += "z"
+      elsif options[:compressor] == "bzip2"
+        options[:cmd] += "j"
+      end
+
+      options[:cmd] += "f #{options[:from]} -C #{options[:to]}"
+      @node.run(options)
+    end
+
+    def link(options = {})
+      error "from is required" unless options[:from]
+      error "to is required" unless options[:to]
+
+      options[:cmd] = "ln -s #{options[:from]} #{options[:to]}"
+      @node.run(options)
+    end
+
+    def chown(options = {})
+      error "dir is required" unless options[:dir]
+      error "user is required" unless options[:user]
+      error "group is required" unless options[:group]
+
+      options[:cmd] = "chown -R #{options[:user]}:#{options[:group]} "
+      options[:cmd] += "#{options[:dir]}"
+
+      @node.run(options)
+    end
+
+    def touch(options = {})
+      error "file is required" unless options[:file]
+
+      options[:cmd] = "touch #{options[:file]}"
+      @node.run(options)
+    end
+  end
+end