dployr 0.0.2 → 0.0.3

data/lib/dployr/compute/aws.rb

@@ -5,94 +5,93 @@ module Dployr
   module Compute
     class AWS
 
-        def initialize(region)
-          @options = {
-            region: region[0..-2],
-            provider: 'AWS',
-            aws_access_key_id: ENV["AWS_ACCESS_KEY"],
-            aws_secret_access_key: ENV["AWS_SECRET_KEY"]
-          }
-          @compute = Fog::Compute.new @options
-        end
+      def initialize(region)
+        @options = {
+          region: region[0..-2],
+          provider: 'AWS',
+          aws_access_key_id: ENV["AWS_ACCESS_KEY"],
+          aws_secret_access_key: ENV["AWS_SECRET_KEY"]
+        }
+        @compute = Fog::Compute.new @options
+      end
 
-        # private
-        def get_instance(name, states)
-          servers = @compute.servers.all
-          servers.each do |instance|            
-            if instance.tags["Name"] == name and states.include? instance.state 
-              return instance
-            end
+      def get_instance(name, states)
+        servers = @compute.servers.all
+        servers.each do |instance|
+          if instance.tags["Name"] == name and states.include? instance.state
+            return instance
           end
-          return nil
         end
+        nil
+      end
 
-        def get_ip(name)
-          instance = get_instance(name, ["running"])
-          if instance
-            return instance.private_ip_address
-          end
-        end
-        
-        def destroy(name)
-          instance = get_instance(name, ["running", "stopped", "stopping"])
-          if instance
-            return instance.destroy
-          end
+      def get_ip(name)
+        instance = get_instance(name, ["running"])
+        instance.private_ip_address if instance
+      end
+
+      def destroy(name)
+        instance = get_instance(name, ["running", "stopped", "stopping"])
+        if instance
+          instance.destroy
+        else
           raise "Instance #{name} not found"
         end
-        
-        def halt(name)
-          instance = get_instance(name, ["running"])
-          if instance
-            return instance.stop
-          end
+      end
+
+      def halt(name)
+        instance = get_instance(name, ["running"])
+        if instance
+          instance.stop
+        else
           raise "Instance #{name} not found"
         end
+      end
 
-        def start(attributes, region)
-          server = get_instance(attributes["name"], ["stopped", "stopping"])
-          if server
-            puts "Starting stopped instance for #{attributes["name"]} in #{region}...".yellow
-            server.start
-          else
-            puts "Creating new instance for #{attributes["name"]} in #{region}...".yellow
-            options = {
-              availability_zone: region,
-              flavor_id: attributes["instance_type"],
-              image_id: attributes["ami"],
-              key_name: attributes["keypair"],
-              subnet_id: attributes["subnet_id"],
-              security_group_ids: attributes["security_groups"],
-              tags: { Name: attributes["name"] }
-              #private_ip_address        : private_ip_address,
-              #user_data                 : user_data,
-              #elastic_ip                : elastic_ip,
-              #allocate_elastic_ip       : allocate_elastic_ip,
-              #block_device_mapping      : block_device_mapping,
-              #instance_initiated_shutdown_behavior : terminate_on_shutdown == true ? "terminate" : nil,
-              #monitoring                : monitoring,
-              #ebs_optimized             : ebs_optimized
-            }
-            puts options.to_yaml
-            server = @compute.servers.create(options)
-          end         
-          print "Wait for instance to get online".yellow
-          server.wait_for { print ".".yellow; ready? }
-          
-          print "\nWait for ssh to get ready...".yellow
-          while true
-            begin
-              Net::SSH.start(server.private_ip_address, attributes["username"], :keys => attributes["private_key_path"]) do |ssh|
-                print "\n"
-                return server.private_ip_address
-              end
-            rescue Exception => e
-              print ".".yellow
-              sleep 2
+      def start(attributes, region)
+        server = get_instance(attributes["name"], ["stopped", "stopping"])
+        if server
+          puts "Starting stopped instance for #{attributes["name"]} in #{region}...".yellow
+          server.start
+        else
+          puts "Creating new instance for #{attributes["name"]} in #{region}...".yellow
+          options = {
+            availability_zone: region,
+            flavor_id: attributes["instance_type"],
+            image_id: attributes["ami"],
+            key_name: attributes["keypair"],
+            subnet_id: attributes["subnet_id"],
+            security_group_ids: attributes["security_groups"],
+            tags: { Name: attributes["name"] }
+            #private_ip_address        : private_ip_address,
+            #user_data                 : user_data,
+            #elastic_ip                : elastic_ip,
+            #allocate_elastic_ip       : allocate_elastic_ip,
+            #block_device_mapping      : block_device_mapping,
+            #instance_initiated_shutdown_behavior : terminate_on_shutdown == true ? "terminate" : nil,
+            #monitoring                : monitoring,
+            #ebs_optimized             : ebs_optimized
+          }
+          puts options.to_yaml
+          server = @compute.servers.create(options)
+        end
+        print "Wait for instance to get online".yellow
+        server.wait_for { print ".".yellow; ready? }
+
+        print "\nWait for ssh to get ready...".yellow
+        while true
+          begin
+            Net::SSH.start(server.private_ip_address, attributes["username"], :keys => attributes["private_key_path"]) do |ssh|
+              print "\n"
+              return server.private_ip_address
             end
+          rescue Exception => e
+            print ".".yellow
+            sleep 2
           end
-          print "\n"
-          return null
+        end
+        print "\n"
+        nil
       end
 
     end

data/lib/dployr/compute/gce.rb

@@ -0,0 +1,134 @@
+require 'fog'
+require 'net/ssh'
+
+module Dployr
+  module Compute
+    class GCE
+
+        def initialize(region)
+          @options = {
+            provider: 'Google',
+            google_project: ENV["GOOGLE_PROJECT_ID"],
+            google_client_email: ENV["GOOGLE_CLIENT_EMAIL"],
+            google_key_location: ENV["GOOGLE_KEY_LOCATION"]
+          }
+          @compute = Fog::Compute.new @options
+        end
+
+        # https://developers.google.com/compute/docs/instances
+        # private
+        def get_instance(name, states)
+          servers = @compute.servers.all
+          servers.each do |instance|
+            if instance.name == name and states.include? instance.state
+              return instance
+            end
+          end
+          return nil
+        end
+
+        def get_ip(name)
+          instance = get_instance(name, ["PROVISIONING", "STAGING", "RUNNING"])
+          if instance
+            return instance.private_ip_address
+          end
+        end
+
+        def destroy(name)
+          instance = get_instance(name, ["RUNNING", "STOPPED"])
+          if instance
+            puts "Destroying instance #{name}...".yellow
+            instance.destroy(async = false)
+            puts "Destroying disk #{name}...".yellow
+            disk = @compute.disks.get(name)
+            disk.destroy
+            # Bug in fog. It return "persistent-disk-0" instead of boot disk name (usually the same name of the machine)
+            # instance.disks.each do |disk|
+            #   gdisk = @compute.disks.get(disk["deviceName"])
+            #   gdisk.destroy
+            # end
+            return   
+          end
+          raise "Instance #{name} not found"
+        end
+
+        def halt(name)
+          instance = get_instance(name, ["RUNNING"])
+          if instance
+            instance.disks.each do |disk|
+              if disk["autoDelete"] == true
+                raise "Cannot halt instance with autoDelete disks"
+              end
+            end
+            return instance.destroy
+          end
+          raise "Instance #{name} not found"
+        end
+        
+        def create_disk(name, size_gb, zone_name, image_name)
+          disk = @compute.disks.get(name)
+          if disk != nil
+            puts "Disk #{name} already created. Reusing it.".yellow
+            return disk
+          else
+            puts "Creating new boot disk #{name}...".yellow
+            disk = @compute.disks.create(
+              name: name,
+              size_gb: size_gb,
+              zone_name: zone_name,
+              source_image: image_name
+            )
+          
+            disk.wait_for { disk.ready? }
+            return disk
+          end
+        end
+
+        def start(attributes, region)
+          server = get_instance(attributes["name"], ["stopped", "stopping"])
+          if server
+            puts "Starting stopped instance for #{attributes["name"]} in #{region}...".yellow
+            server.start
+          else
+            disks = create_disk(attributes["name"], 10, region, attributes["image_name"])
+            if defined? attributes["autodelete_disk"]
+              autodelete_disk  = attributes["autodelete_disk"]
+            else
+              autodelete_disk = false
+            end
+            
+            puts "Creating new instance for #{attributes["name"]} in #{region}...".yellow
+            
+            options = {
+              name: attributes["name"],
+              zone_name: region,
+              machine_type: attributes["instance_type"],
+              network: attributes["network"],
+              disks: [disks.get_as_boot_disk(true, autodelete_disk)],
+            }
+            
+            puts options.to_yaml
+            server = @compute.servers.create(options)
+          end
+          print "Wait for instance to get online".yellow
+          server.wait_for { print ".".yellow; ready? }
+
+          print "\nWait for ssh to get ready...".yellow
+          while true
+            begin
+              Net::SSH.start(server.private_ip_address, attributes["username"], :keys => attributes["private_key_path"]) do |ssh|
+                print "\n"
+                return server.private_ip_address
+              end
+            rescue Exception => e
+              print ".".yellow
+              sleep 2
+            end
+          end
+          print "\n"
+          return nil
+      end
+
+    end
+  end
+end

data/lib/dployr/config/file_utils.rb

@@ -18,18 +18,16 @@ module Dployr
       end
 
       def discover(dir = Dir.pwd)
-        [nil].concat(EXTENSIONS).each do |ext|
-          (0..5).each do |n|
-            FILENAMES.each do |file|
-              file += ".#{ext}" if ext
-              file_path = File.join dir, ('../' * n), file
-              if File.file? file_path
-                return File.expand_path file_path, dir
-              end
+        (0..5).each do |n|
+          FILENAMES.each do |file|
+            [nil].concat(EXTENSIONS).each do |ext|
+              file_name = "#{file}.#{ext}" if ext
+              file_path = File.join dir, ('../' * n), (file_name or file)
+              return File.expand_path file_path, dir if File.file? file_path
             end
           end
         end
-        return nil
+        nil
       end
 
     end

data/lib/dployr/configuration.rb

@@ -7,11 +7,12 @@ module Dployr
 
     attr_reader :default, :instances
 
-    def initialize
+    def initialize(attributes = {})
       @default = nil
       @config = nil
       @instances = []
       @merged = false
+      @attributes = attributes.is_a?(Hash) ? attributes : {}
       yield self if block_given?
     end
 
@@ -35,6 +36,7 @@ module Dployr
 
     def get_config(name, attributes = {})
       instance = get_instance name
+      attributes = @attributes.merge (attributes or {})
       raise ArgumentError.new "Instance '#{name.to_s}' do not exists" if instance.nil?
       replace_variables merge_config(instance), replace_variables(attributes)
     end

data/lib/dployr/init.rb

@@ -34,8 +34,7 @@ module Dployr
 
     def initialize(attributes = {})
       @@instance = self
-      @attributes = attributes
-      @config = Dployr::Configuration.new
+      @config = Dployr::Configuration.new attributes
       @file_path = nil
     end
 

data/lib/dployr/scripts/default_hooks.rb

@@ -1,19 +1,12 @@
-require 'logger'
-require 'dployr/utils'
-require 'colorize'
-
 module Dployr
   module Scripts
     class Default_Hooks
 
-      include Dployr::Utils
-
       def initialize(ip, config, stage, command)
-        @log = Logger.new STDOUT
         @config = config
         @ip = ip
         @stage = stage
-      
+
         if @config[:scripts]["pre-#{@stage}"]
           Dployr::Scripts::Hook.new @ip, config, "pre-#{@stage}"
         end
@@ -25,7 +18,7 @@ module Dployr
           Dployr::Scripts::Hook.new @ip, config, "#{@stage}"
         end
       end
-      
+
     end
   end
 end

data/lib/dployr/scripts/hook.rb

@@ -1,15 +1,8 @@
-require 'logger'
-require 'dployr/utils'
-require 'colorize'
-
 module Dployr
   module Scripts
     class Hook
 
-      include Dployr::Utils
-
       def initialize(ip, instance, stage)
-        @log = Logger.new STDOUT
         @ip = ip
         @instance = instance
         @stage = stage
@@ -24,12 +17,14 @@ module Dployr
         username = attrs["username"]
         private_key_path = attrs["private_key_path"]
 
-        puts "STAGE '#{@stage}':".yellow
+        puts "Running stage '#{@stage}':".yellow
         @instance[:scripts][@stage].each do |script|
           if script["target"]
             Dployr::Scripts::Scp.new @ip, host, username, private_key_path, script
-          else
+          elsif script["remote_path"]
             Dployr::Scripts::Shell.new @ip, host, username, private_key_path, script
+          elsif script["local_path"]
+            Dployr::Scripts::Local_Shell.new script
           end
         end
       end

data/lib/dployr/scripts/local_shell.rb

@@ -0,0 +1,29 @@
+require 'net/ssh'
+
+module Dployr
+  module Scripts
+    class Local_Shell
+
+      def initialize(script)
+        @script = script
+        start
+      end
+
+      private
+
+      def start
+        command = @script["local_path"]
+        arguments = @script["args"]
+
+        puts "Running local script '#{command} #{arguments}'".yellow
+        result = system(command + ' ' + arguments)
+        if result == false
+          raise "Exit code non zero when running local script '#{command} #{arguments}'".yellow
+        else
+          puts "Local script '#{command} #{arguments}' finished succesfully".yellow
+        end
+      end
+
+    end
+  end
+end

data/lib/dployr/scripts/scp.rb

@@ -1,18 +1,11 @@
-require 'logger'
 require 'net/scp'
-require 'colorize'
-require 'dployr/utils'
 
 module Dployr
   module Scripts
     class Scp
 
-      include Dployr::Utils
-
       def initialize(ip, host, username, private_key_path, script)
-
         begin
-          @log = Logger.new STDOUT
           puts "Connecting to #{host} (SCP)...".yellow
           Net::SCP.start(ip, username, :keys => [private_key_path]) do |scp|
             source = script["source"]
@@ -20,12 +13,11 @@ module Dployr
             puts "Coping #{source} -> #{target}".yellow
             scp.upload(source, target, :recursive => true, :preserve => true)
           end
-
         rescue Exception => e
-          @log.error e
           raise Error.new "Cannot copy to remote: #{e}"
         end
       end
+
     end
   end
 end

data/lib/dployr/scripts/shell.rb

@@ -1,28 +1,16 @@
-require 'logger'
 require 'net/ssh'
-require 'colorize'
-require 'dployr/utils'
 
 module Dployr
   module Scripts
     class Shell
 
-      include Dployr::Utils
-
       def initialize(ip, host, username, private_key_path, script)
-        @log = Logger.new STDOUT
         @ip = ip
         @host = host
         @username = username
         @private_key_path = private_key_path
         @script = script
-
-        begin
-          start
-        rescue Exception => e
-          @log.error e
-          Process.exit! false
-        end
+        start
       end
 
       private
@@ -30,11 +18,11 @@ module Dployr
       def start
         puts "Connecting to #{@host} (SSH)...".yellow
         Net::SSH.start(@ip, @username, :keys => [@private_key_path]) do |ssh|
-          command = @script["path"]
+          command = @script["remote_path"]
           arguments = @script["args"]
 
           puts "Running remote script '#{command} #{arguments}'".yellow
-          result = ssh_exec!(ssh, command)
+          result = ssh_exec!(ssh, command + ' ' + arguments)
           if result[:exit_code] > 0
             raise "Exit code #{result[:exit_code]} when running script '#{command} #{arguments}'".yellow
           else
@@ -50,35 +38,35 @@ module Dployr
         exit_code = nil
         exit_signal = nil
         ssh.open_channel do |channel|
+          @channel = channel
           channel.exec(command) do |ch, success|
             unless success
               abort "FAILED: couldn't execute command (ssh.channel.exec)"
             end
             channel.on_data do |ch,data|
               stdout_data+=data
-              print "[#{@host}] #{data}".green
+              #print "[#{@host}] #{data}".green
+              print "#{data}".green
             end
 
             channel.on_extended_data do |ch,type,data|
               stderr_data+=data
-              print "[#{@host}] #{data}".red
+              #print "[#{@host}] #{data}".red
+              print "#{data}".red
             end
 
             channel.on_request("exit-status") do |ch,data|
               exit_code = data.read_long
+              @channel.close
             end
-
-            channel.on_request("exit-signal") do |ch, data|
-              exit_signal = data.read_long
-            end
+            
           end
         end
         ssh.loop
         {
           stdout_data: stdout_data,
           stderr_data: stderr_data,
-          exit_code: exit_code,
-          exit_signal: exit_signal
+          exit_code: exit_code
         }
       end
     end

data/lib/dployr/scripts/ssh.rb

@@ -0,0 +1,23 @@
+require 'net/ssh'
+
+module Dployr
+  module Scripts
+    class Ssh
+
+      def initialize(ip, instance)
+        @ip = ip
+        @username = instance[:attributes]["username"]
+        @private_key_path = instance[:attributes]["private_key_path"]
+        run
+      end
+
+      private
+
+      def run
+        puts "ssh -i #{@private_key_path} #{@username}@#{@ip}"
+        system("ssh -i #{@private_key_path} #{@username}@#{@ip}")
+      end
+
+    end
+  end
+end

data/lib/dployr/utils.rb

@@ -46,27 +46,6 @@ module Dployr
       Marshal.load Marshal.dump o
     end
 
-    def parse_matrix(str)
-      hash = {}
-      str.split(';').each do |val|
-        val = val.split '='
-        hash[val.first.strip] = val.last.strip
-      end if str.is_a? String
-      hash
-    end
-
-    def parse_flags(str)
-      hash = {}
-      str.gsub(/\s+/, ' ').strip.split(' ').each_slice(2) do |val|
-        key = val.first
-        if val.first.is_a? String
-          key = key.gsub(/^\-+/, '').strip
-          hash[key] = (val.last or '').strip
-        end
-      end if str.is_a? String
-      hash
-    end
-
     def replace_vars(str)
       str.gsub(/\%\{(\w+)\}/) { yield $1 }
     end

data/lib/dployr/version.rb

@@ -1,3 +1,3 @@
 module Dployr
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/lib/dployr.rb

@@ -1,3 +1,4 @@
+require 'colorize'
 require 'dployr/version'
 require 'dployr/init'
 require 'dployr/configuration'
@@ -9,7 +10,10 @@ require 'dployr/commands/start'
 require 'dployr/commands/stop_destroy'
 require 'dployr/commands/config'
 require 'dployr/commands/execute'
+require 'dployr/commands/ssh'
 require 'dployr/scripts/hook'
 require 'dployr/scripts/default_hooks'
 require 'dployr/scripts/shell'
+require 'dployr/scripts/local_shell'
+require 'dployr/scripts/ssh'
 require 'dployr/scripts/scp'