mccloud 0.0.13 → 0.0.14

data/lib/mccloud/provider/aws/stack.rb

@@ -0,0 +1,243 @@
+require 'open-uri'
+require 'json'
+
+module Mccloud
+  module Provider
+  module Core
+
+  class Stack
+    attr_accessor :name
+    attr_accessor :params
+    attr_accessor :provider
+    attr_accessor :provider_options
+    attr_accessor :create_options
+    attr_accessor :jsonfile
+    attr_accessor :instance
+    attr_accessor :rewrite_names
+
+    attr_accessor :user
+    attr_accessor :private_key
+    attr_accessor :public_key
+    attr_accessor :key_name
+    attr_accessor :userdata_file
+
+
+    def initialize(env)
+      super(env)
+#      @forwardings=Array.new
+       @rewrite_names=true
+       @user=Hash.new
+       @private_key=Hash.new
+       @public_key=Hash.new
+       @userdata_file=Hash.new
+       @key_name=Hash.new
+       @provider_options={:region => "us-east-1"}
+    end
+
+    def private_key_for_instance(machinename)
+      default_private_key=private_key[:default]
+      if private_key[machinename].nil?
+        return default_private_key
+      else
+        return private_key[machinename]
+      end
+    end
+
+    def public_key_for_instance(machinename)
+      default_public_key=public_key[:default]
+      if public_key[machinename].nil?
+        return default_public_key
+      else
+        return public_key[machinename]
+      end
+    end
+
+    def user_for_instance(machinename)
+      default_user=user[:default]
+      if user[machinename].nil?
+        return default_user
+      else
+        return user[machinename]
+      end
+    end
+
+    def key_name_for_instance(machinename)
+      default_key_name=key_name[:default]
+      if key_name[machinename].nil?
+        return default_key_name
+      else
+        return key_name[machinename]
+      end
+    end
+
+    def userdata_file_for_instance(machinename)
+      default_userdata_file=userdata_file[:default]
+      if userdata_file[machinename].nil?
+        return default_userdata_file
+      else
+        return userdata_file[machinename]
+      end
+    end
+
+    def instance
+#      if @this_instance.nil?
+#        begin
+#          @this_instance=Mccloud.environment.config.providers[provider].servers.get(Mccloud.environment.all_servers[name.to_s])
+#        rescue Fog::Service::Error => e
+#          env.ui.info "Error: #{e.message}"
+#          env.ui.info "We could not request the information from your provider #{provider}. We suggest you check your credentials."
+#          env.ui.info "Check configuration file: #{File.join(ENV['HOME'],".fog")}"
+#          exit -1
+#        end
+#      end
+#      return @this_instance
+    end
+
+    def json_rewrite
+      hash=self.json_to_hash
+      unknown_counter=1
+      # First rewrite the Name Tags
+      hash["Resources"].each do  |name,resource|
+
+              if resource["Type"]=="AWS::EC2::Instance"
+                foundName=false
+                foundKeyName=false
+                instance_name=""
+
+                rewrittenTags=Array.new
+
+                 # Loop over each hash
+                 hash["Resources"][name]["Properties"]["Tags"].each do |tag_hash|
+
+                  new_tag_hash=tag_hash
+
+                  # If we found the Name tag rewrite it
+                   if tag_hash["Key"]="Name"
+                     # Need to rewrite name
+                     new_tag_hash={"Value"=>"#{Mccloud.environment.config.mccloud.filter}#{tag_hash["Value"]}", "Key"=>"Name"}
+                     instance_name="#{tag_hash["Value"]}"
+                     foundName=true
+                   end
+
+                   #if tag_hash["Key"]="KeyName"
+                  #   foundKeyName=true
+                   #end
+
+                   rewrittenTags << new_tag_hash
+
+                end #Hash Tags iteration
+                unless foundName
+                  rewrittenTags << {"Value"=>"#{Mccloud.environment.config.mccloud.filter}noname-#{unkown_counter}", "Key"=>"Name"}
+                  instance_name="noname-#{unkown_counter}"
+                  unknown_counter=unknown_counter+1
+                end
+
+                hash["Resources"][name]["Properties"]["Tags"]=rewrittenTags
+
+                unless hash["Resources"][name]["Properties"].has_key?("UserData")
+                  env.ui.info "merging in Userdata file for server #{instance_name} - #{self.userdata_file_for_instance(instance_name)}"
+                  userdata=json_escape_file(self.userdata_file_for_instance(instance_name))
+                  hash["Resources"][name]["Properties"]["UserData"]={ "Fn::Base64" => "#{userdata}" }
+                end
+
+              end #EC2 Instance
+      end
+
+
+      return hash.to_json
+    end
+
+    def json_escape_file(filename)
+      data=''
+        File.open(filename) {|f| data << f.read}
+        return self.json_escape(data)
+    end
+
+
+
+    def json_escape(string)
+      parse = JSON.parse({ 'json' => string }.to_json)
+      return parse['json']
+    end
+
+
+    def json
+      begin
+        json=open(@jsonfile) {|f| f.read }
+        hash=JSON.parse(json)
+      rescue Errno::ENOENT => e
+        env.ui.info "Error getting json file -  #{e.message}"
+        exit
+      rescue JSON::ParserError => e
+        env.ui.info "Error parsing json file -  #{e.message}"
+        exit
+      end
+      return json
+    end
+
+    def exists?
+      false
+    end
+
+    def json_to_hash
+      hash=nil
+      begin
+        hash=JSON.parse(self.json)
+      rescue JSON::ParserError => e
+        env.ui.info "Error parsing json file -  #{e.message}"
+        exit
+      end
+      return hash
+    end
+
+    def filtered_instance_names
+      fullname_instances=self.instance_names
+      short_instances=[]
+      filter=Mccloud.environment.config.mccloud.filter
+      fullname_instances.each do |instancename|
+        if instancename.start_with?(filter)
+          short=instancename
+          short[filter]=""
+          short_instances << short
+        end
+      end
+      return short_instances
+    end
+
+
+    def instance_names
+      hash=self.json_to_hash
+
+      instances=[]
+      resources=hash["Resources"]
+      resources.each do  |name,resource|
+
+              if resource["Type"]=="AWS::EC2::Instance"
+
+                resources[name]["Properties"]["Tags"].each do |tag|
+
+                  if tag["Key"]=="Name"
+                    instances << tag["Value"]
+                  end
+                end
+#                instances << hash["Resources"][name]["Properties"]["Tags"]
+#                      hash["Resources"][name]["Properties"]["Tags"]=[{"Value"=>"mccloud - development - patrick - drupalblub", "Key"=>"Name"}]
+            else
+               # env.ui.info "found something else"
+              end
+      end
+      return instances
+    end
+
+    def reload
+      #@this_instance=nil
+    end
+    def forward_port(name,local,remote)
+      #forwarding=Forwarding.new(name,local,remote)
+      #forwardings << forwarding
+    end
+  end
+
+end
+end
+end #Module Mccloud

data/lib/mccloud/provider/aws/vm/bootstrap.rb

@@ -0,0 +1,13 @@
+require 'mccloud/util/platform'
+
+module Mccloud::Provider
+  module Aws
+    module VmCommand
+
+      def _bootstrap(command,options=nil)
+         ssh_bootstrap(command,options)
+      end
+
+    end #module
+  end #Module
+end #module

data/lib/mccloud/provider/aws/vm/destroy.rb

@@ -0,0 +1,21 @@
+module Mccloud::Provider
+  module Aws
+    module VmCommand
+
+      def destroy(options)
+
+        unless raw.nil? || raw.state == "shutting-down" || raw.state =="terminated"
+          env.ui.info "[#{@name}] - Destroying machine (#{raw.id})"
+          raw.destroy
+
+          raw.wait_for {  print "."; STDOUT.flush; state=="terminated"}
+          env.ui.info ""
+        else
+          env.ui.info "[#{@name}] - Machine is already terminated #{@raw.id}"
+        end
+
+      end
+
+    end #module
+  end #module
+end #module

data/lib/mccloud/provider/aws/vm/forward.rb

@@ -0,0 +1,17 @@
+module Mccloud::Provider
+  module Aws
+    module VmCommand
+
+        def forward(command,options={})
+          @forward_threads=Array.new
+          unless raw.nil?
+            return self.ssh_forward(options)
+          else
+            env.ui.info "[#{self.name}] not yet created"
+            return [] 
+          end
+        end
+
+    end #module
+  end #module
+end #module

data/lib/mccloud/provider/aws/vm/halt.rb

@@ -0,0 +1,24 @@
+module Mccloud::Provider
+  module Aws
+    module VmCommand
+
+      def halt(options)
+
+        if self.running?
+          env.ui.info "Halting machine #{@name}(#{@raw.id})"
+          raw.stop
+          raw.wait_for { printf "."; STDOUT.flush; state=="stopped"}
+          env.ui.info ""
+        else
+          unless @raw.nil?
+            env.ui.info "#{@name}(#{@raw.id}) is already halted."
+          else
+            env.ui.info "#{@name} is not yet created or was terminated"
+          end
+        end
+
+      end
+
+    end #module
+  end #module
+end #module

data/lib/mccloud/provider/aws/vm/package.rb

@@ -0,0 +1,63 @@
+module Mccloud::Provider
+  module Aws
+    module VmCommand
+
+      def package(options=nil)
+
+        #f=Fog::Compute.new({ :region => "eu-west-1", :provider => "AWS"})
+        # i=f.create_image("i-c1ac2bb7","name","description")
+        # f.images.all({ "Owner" => "self"})
+        # f.deregister_image("ami-796d5b0d")
+
+        time=Time.new
+        strtime=time.strftime("%Y-%m-%d-%H-%M-%S")
+        name=""
+
+        if options["name"].nil?
+          name="#{@name}-#{strtime}"
+        else
+          name=options["name"]
+        end
+
+        description=""
+        if options["description"].nil?
+          description="Autogenerated snapshot from machine #{@name}"
+        else
+          description=options["description"]
+        end
+
+        begin
+          puts raw.id
+          result=@provider.raw.create_image(raw.id,name,description)
+          imageId=result.body["imageId"]
+          env.ui.info "[#{@name}] image #{imageId} with #{description} being created"
+          unless options["dontwait"]
+            sleep 3
+            counter=0
+            max_tries=5
+            #Pending
+            state="pending"
+            until state!="pending" do
+              print "."
+              sleep 2
+              image=@provider.raw.images.get(imageId)
+
+              if image.nil?
+                sleep 3
+                print "."
+              else
+                state=image.state
+              end
+            end
+            env.ui.info ""
+            env.ui.info "[#{@name}] creation done!"
+          end
+        rescue Fog::Service::Error => fogerror
+          env.ui.error "[Error] #{fogerror}"
+
+        end
+      end
+
+    end #module
+  end #module
+end #module

data/lib/mccloud/provider/aws/vm/provision.rb

@@ -0,0 +1,25 @@
+module Mccloud::Provider
+  module Aws
+    module VmCommand
+
+      def _provision(options=nil)
+        unless raw.nil?
+
+          if raw.ready?
+            self.share
+
+            @provisioners.each do |provisioner|
+              env.ui.info "[#{@name}] - starting provisioning with #{provisioner.name} as provisioner"
+              provisioner.run(self)
+            end
+          else
+            raise Mccloud::Error, "[#{@name}] - machine is not running, skipping provisioning"
+          end
+        else
+          raise Mccloud::Error, "[#{@name}] - machine doesn't exit yet"
+        end
+      end
+
+    end #module
+  end #module
+end #module

data/lib/mccloud/provider/aws/vm/reload.rb

@@ -0,0 +1,13 @@
+module Mccloud::Provider
+  module Aws
+    module VmCommand
+      def reload(options)
+         env.logger.info "Checking if #{@name} is running: #{self.running?}"
+        if self.running?
+          self.halt(options)
+        end
+        self.up(options)
+      end
+    end
+  end
+end

data/lib/mccloud/provider/aws/vm/rsync.rb

@@ -0,0 +1,11 @@
+module Mccloud::Provider
+  module Aws
+    module VmCommand
+
+        def rsync(src,dest,options)
+          super(src,dest,options)
+        end
+
+    end #module
+  end #module
+end #module

data/lib/mccloud/provider/aws/vm/scp.rb

@@ -0,0 +1,21 @@
+module Mccloud::Provider
+  module Aws
+    module VmCommand
+
+      def transfer(src,dest,options = {})
+        scp(src,dest,options)
+      end
+
+       def scp(local_path, remote_path, scp_options = {})
+         unless File.exists?(local_path)
+          raise Mccloud::Error,"scp failed: #{local_path} does not exist"
+         end
+         #@raw.scp(src,dest)
+         scp_options[:key_data] = [@raw.private_key] if @raw.private_key
+
+         ::Fog::SCP.new(self.ip_address, @raw.username, scp_options).upload(local_path, remote_path, {})
+      end
+
+       end #module
+      end #module
+    end #module

data/lib/mccloud/provider/aws/vm/ssh.rb

@@ -0,0 +1,11 @@
+module Mccloud::Provider
+  module Aws
+    module VmCommand
+
+        def ssh(command,options={})
+          super(command,options)
+        end
+
+    end #module
+  end #module
+end #module

data/lib/mccloud/provider/aws/vm/up.rb

@@ -0,0 +1,133 @@
+module Mccloud::Provider
+  module Aws
+    module VmCommand
+
+     def security_group_has_ssh_open?(group)
+      return false
+     end
+
+     def security_group_exists?(group)
+      return !@provider.raw.security_groups.get(group).nil?
+     end
+
+    def security_group_is_managed_by_mccloud?(group)
+        return /^mccloud/ =~ group
+    end
+
+     def check_security_groups(groups)
+        if @provider.check_security_groups
+          # Iterate over all groups
+          groups.each do |group|
+
+            if security_group_exists?(group)
+              env.logger.info "security group #{group} exists"
+            else
+              env.logger.info "security group #{group} does not yet exist"
+              if security_group_is_managed_by_mccloud?(group)
+                # Managed by mccloud
+                env.logger.info "security group #{group} starts with mccloud"
+                env.ui.info "Creating security group #{group}"
+                @provider.create_sg(group)
+              else
+                # Not managed by mccloud
+                raise Mccloud::Error, "security group #{group} does not exits. And we only managed security groups with prefix mccloud"
+              end
+            end
+
+            unless security_group_has_ssh_open?(group)
+            end
+          end
+        end
+      end
+
+    def key_is_managed_by_mccloud?(keyname)
+        return /^mccloud/ =~ keyname
+    end
+
+      def check_key(key_name)
+        if @provider.check_keypairs
+          raw_keypair=@provider.raw.key_pairs.get(key_name)
+          if raw_keypair.nil?
+                raise Mccloud::Error, "keypair #{key_name} does not exits. And we only managed keys with prefix mccloud"
+            raise Mccloud::Error, "keypair #{key_name} does not exist"
+          end
+        end
+      end
+
+      def up(options={})
+
+        if raw.nil? || raw.state =="terminated"
+
+          create_options= {
+            :private_key_path => @private_key_path ,
+            :public_key_path => @public_key_path,
+            :availability_zone => @zone,
+            :image_id => @ami,
+            :flavor_id => @flavor,
+            :key_name => @key_name,
+            :user_data => @user_data,
+            :groups => @security_groups,
+            :tags             => {"Name" => "#{@provider.filter}#{@name}"}
+          }.merge(@create_options)
+
+          check_security_groups(create_options[:groups])
+          check_key(create_options[:key_name])
+
+          env.ui.info "Creating new vm #{@name} for provider #{@provider.name}"
+          begin
+            @raw=@provider.raw.servers.create(create_options)
+          rescue ::Fog::Compute::AWS::NotFound => ex
+            raise ::Mccloud::Error, "Error creating the new server: #{ex}"
+            return
+          end
+
+          env.ui.info "[#{@name}] - Waiting for the machine to become accessible"
+          raw.wait_for { printf "."; STDOUT.flush;  ready?}
+          env.ui.info ""
+
+          # Wait for ssh to become available ...
+          env.ui.info "[#{@name}] - Waiting for ssh port to become available"
+
+          Mccloud::Util::Ssh.execute_when_tcp_available(self.ip_address, { :port => @port, :timeout => 6000 }) do
+            env.ui.info "[#{@name}] - Ssh Port is available"
+          end
+
+          Mccloud::Util::Ssh.when_ssh_login_works(self.ip_address, { :user => @user, :port => @port, :timeout => 6000 ,:keys => [@private_key_path]}) do
+            env.ui.info "[#{@name}] - Ssh login works , proceeding with bootstrap"
+          end
+          # No bootstrap to provide
+          self._bootstrap(nil,options)
+
+        else
+          state=raw.state
+          if state =="stopped"
+            env.ui.info "Booting up machine #{@name}"
+            raw.start
+            raw.wait_for { printf ".";STDOUT.flush;  ready?}
+            env.ui.info ""
+          else
+            unless raw.state == "shutting-down" || raw.state =="terminated"
+              env.ui.info "[#{@name}] - already running."
+            else
+              env.ui.info "[#{@name}] - can't start machine because it is in state #{raw.state}"
+              return
+            end
+          end
+        end
+
+        unless options["noprovision"]
+          env.ui.info "[#{@name}] - Waiting for ssh to become available"
+          Mccloud::Util::Ssh.execute_when_tcp_available(self.ip_address, { :port => @port, :timeout => 6000 }) do
+            env.ui.info "[#{@name}] - Ssh is available , proceeding with provisioning"
+          end
+
+          env.ui.info "[#{@name}] - provision step #{@name}"
+          self._provision(options)
+        end
+
+
+      end
+
+    end #module
+  end #module
+end #module