mybot 0.0.4 → 0.1.0

data/lib/mybot/utils.rb

@@ -1,7 +0,0 @@
-module Mybot
-	module Utils
-		def lib_to_path(lib)
-			lib.split("::").map{ |l| l.downcase }.join("/")
-		end
-	end
-end

data/vendor/lib/core/fs.rb

@@ -1,191 +0,0 @@
-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).stdout.include?("EXISTS") ? true : false
-    end
-
-    def create(options = {})
-      unless options[:file] || options[:dir]
-        error "file or dir is required"
-      end
-
-      if options[:file]
-        options[:pattern] = "/tmp/mybot.XXXXX"
-        tmp = mktemp(options)
-
-        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 mktemp(options = {})
-      error "pattern required" unless options[:pattern]
-
-      options[:cmd] = "mktemp #{options[:pattern]}"
-      sudo = options[:sudo]
-      options[:sudo] = false
-      tmp = @node.run(options).stdout
-      options[:sudo] = sudo
-      tmp.strip
-    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.stdout
-    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

data/vendor/lib/core/osx/git.rb

@@ -1,31 +0,0 @@
-module Core
-	module Osx
-		class Git < Mybot::Lib
-			def initialize(node)
-				@node = node
-			end
-
-			def installed?(options = {})
-				options[:file] = "/usr/bin/git"
-				@node.exists?(options)
-			end
-
-			def clone(options = {})
-				error "repo not specified" unless options[:repo]
-
-				options[:dest] ||= ""
-				options[:key_passphrase] ||= ""
-				options[:cmd] = "git clone #{options[:repo]} #{options[:dest]}"
-				@node.run(options) do |cmd|
-					cmd.on "Are you sure you want to continue connecting (yes/no)?" do
-						cmd.write "yes"
-					end
-
-					cmd.on "Enter passphrase for key" do
-						cmd.write options[:key_passphrase]
-					end
-				end
-			end
-		end
-	end
-end

data/vendor/lib/core/osx/rails.rb

@@ -1,31 +0,0 @@
-module Core
-	module Osx
-		class Rails < Mybot::Lib
-			def initialize(node)
-				@node = node
-				@node.use [
-					"core/fs",
-					"core/osx/git"
-				]
-			end
-
-			def prepare_release(options = {})
-				error "repo is required" unless options[:repo]
-				error "release is required" unless options[:release]
-
-				options[:dir] = "/tmp/#{options[:release]}"
-				@node.fs.remove(options)
-
-				options[:file] = "/tmp/#{options[:release]}.tar.gz"
-				@node.fs.remove(options)
-
-				options[:dest] = "/tmp/#{options[:release]}"
-				@node.git.clone(options)
-
-				options[:from] = "/tmp/#{options[:release]}"
-				options[:to] = "/tmp/#{options[:release]}.tar.gz"
-				@node.fs.compress(options)
-			end
-		end
-	end
-end

data/vendor/lib/core/osx/static.rb

@@ -1,31 +0,0 @@
-module Core
-	module Osx
-		class Static < Mybot::Lib
-			def initialize(node)
-				@node = node
-				@node.use [
-					"core/fs",
-					"core/osx/git"
-				]
-			end
-
-			def prepare_release(options = {})
-				error "repo is required" unless options[:repo]
-				error "release is required" unless options[:release]
-
-				options[:dir] = "/tmp/#{options[:release]}"
-				@node.fs.remove(options)
-
-				options[:file] = "/tmp/#{options[:release]}.tar.gz"
-				@node.fs.remove(options)
-
-				options[:dest] = "/tmp/#{options[:release]}"
-				@node.git.clone(options)
-
-				options[:from] = "/tmp/#{options[:release]}"
-				options[:to] = "/tmp/#{options[:release]}.tar.gz"
-				@node.fs.compress(options)
-			end
-		end
-	end
-end

data/vendor/lib/core/ubuntu/apache.rb

@@ -1,42 +0,0 @@
-module Core
-	module Ubuntu
-		class Apache < Mybot::Lib
-			def initialize(node)
-				@node = node
-				@node.use [
-					"core/fs",
-					"core/ubuntu/apt",
-					"core/ubuntu/service"
-				]
-				@apache2conf_tpl = tpl_file "core/ubuntu/apache/apache2.conf.erb"
-			end
-
-			def installed?(options = {})
-				@node.fs.exists?({ :file => "/usr/sbin/apache2"} )
-			end
-
-			def install(options = {})
-				options[:pkg] = "apache2"
-				@node.apt.install(options)
-			end
-
-			def remove(options = {})
-				options[:pkg] = "apache2"
-				@node.apt.remove(options)
-			end
-
-			def reconfigure(options = {})
-				error "config is required" unless options[:config]
-
-				options[:file] = "/etc/apache2/apache2.conf"
-				@node.fs.remove(options)
-
-				options[:content] = @apache2conf_tpl.render(options[:config])
-				@node.fs.create(options)
-
-				options[:service] = "apache2"
-				@node.service.restart(options)
-			end
-		end
-	end
-end

data/vendor/lib/core/ubuntu/apt.rb

@@ -1,57 +0,0 @@
-module Core
-	module Ubuntu
-		class Apt < Mybot::Lib
-			DF = "DEBIAN_FRONTEND=noninteractive"
-
-			def initialize(node)
-				@node = node
-			end
-
-			def update(options = {})
-				options[:cmd] = "#{DF} apt-get update"
-				@node.run(options) do |cmd|
-					cmd.on "dpkg was interrupted" do
-						dpkg_reconfigure(options)
-					end
-
-					cmd.on "Could not get lock" do
-						error "Cannot update"
-					end
-				end
-			end
-
-			def upgrade(options = {})
-				options[:cmd] = "#{DF} apt-get upgrade -y"
-				@node.run(options)
-			end
-
-			def dist_upgrade(options = {})
-				options[:cmd] = "#{DF} apt-get dist-upgrade -y"
-				@node.run(options)
-			end
-
-			def install(options = {})
-				error "pkg not specified" unless options[:pkg]
-
-				options[:cmd] = "#{DF} apt-get install -y #{options[:pkg]}"
-				@node.run(options) do |cmd|
-					cmd.on "dpkg was interrupted" do
-						dpkg_reconfigure(options)
-					end
-				end
-			end
-
-			def remove(options = {})
-				error "pkg not specified" unless options[:pkg]
-
-				options[:cmd] = "#{DF} apt-get --purge autoremove -y #{options[:pkg]}"
-				@node.run(options)
-			end
-
-			def dpkg_reconfigure(options = {})
-				options[:cmd] = "#{DF} dpkg --configure -a"
-				@node.run(options)
-			end
-		end
-	end
-end

data/vendor/lib/core/ubuntu/git.rb

@@ -1,48 +0,0 @@
-module Core
-	module Ubuntu
-		class Git < Mybot::Lib
-			def initialize(node)
-				@node = node
-				@node.use [
-					"core/fs",
-					"core/ubuntu/apt"
-				]
-			end
-
-			def installed?(options = {})
-				options[:file] = "/usr/bin/git"
-				@node.fs.exists?(options)
-			end
-
-			def install(options = {})
-				options[:pkg] = "git"
-				@node.apt.install(options)
-			end
-
-			def remove(options = {})
-				options[:pkg] = "git"
-				@node.apt.remove(options)
-			end
-
-			def clone(options = {})
-				error "repo not specified" unless options[:repo]
-
-				options[:dest] ||= ""
-				options[:cmd] = "git clone #{options[:repo]} #{options[:dest]}"
-				@node.run(options)
-			end
-
-			def init(options = {})
-				error "repo not specified" unless options[:repo]
-
-				options[:cmd] = "git init #{options[:repo]}"
-
-				if options[:bare]
-					options[:cmd] += " --bare"
-				end
-
-				@node.run(options)
-			end
-		end
-	end
-end