asteroid 0.0.1

data/lib/asteroid/instance.rb

@@ -0,0 +1,113 @@
+require 'net/ssh'
+
+require_relative './instance/vars'
+require_relative './instance/scp'
+require_relative './instance/ssh'
+require_relative './instance/command'
+
+
+module Asteroid
+
+  class MissingAttributeError < StandardError
+    def initialize(name)
+      @attribute_name = name
+    end
+
+    def attribute
+      @attribute_name
+    end
+  end
+
+  class Instance
+
+    attr_accessor :logger
+
+    attr_reader :server, 
+                :provider,
+                :type
+
+
+    def initialize(options = {})
+      @provider = options.delete :provider
+      @server = options.delete :server
+      @type = options.delete :type
+
+      @attributes = options
+
+      # Validate Attributes
+      require_attribute :name
+      require_attribute :id
+
+      provider.required_instance_attributes.each do |att|
+        require_attribute att
+      end
+
+      # The type is added on the name
+      @attributes[:type] ||= if @attributes[:name]
+        @attributes[:name].match(/[a-z]+/)[0].to_sym
+      end
+    end
+
+    def self.all
+      instances = Provider.all.instances
+      instances.map do |info|
+        new info
+      end
+    end
+
+    def self.first(type)
+      all_with_type(type).first
+    end
+
+    def self.all_with_type(type)
+      all.select{|i| i.type == type}
+    end
+
+    def password(username = nil)
+      username ||= self["login.username"]
+      password_filename = File.join(Asteroid::Config.password_dir, "/instance_#{@id}-user_#{username}")
+      if File.exists? password_filename
+        File.read(password_filename)
+      else
+        password = SecureRandom.hex(64)
+        File.open(password_filename, 'w'){|f| f.write password}
+        password
+      end
+    end
+
+    def server_defaults
+      server.instance_config
+    end
+
+    def server
+      @server ||= Server.named self.type.to_s
+    end
+
+    def self.find(id)
+      all.select{|i| i.id == id}.first
+    end
+
+    def env
+      {
+        "INSTANCE_PRIVATE_KEY" => self.server.ssh_key_filename,
+        "INSTANCE_SSH_PORT" => self["ssh.port"].to_i,
+        "INSTANCE_SSH_LOGIN" => self["login.username"],
+        "INSTANCE_IP_ADDRESS" => self.ip_address,
+        "INSTANCE_ID" => self.id,
+      }
+    end
+
+    def destroy
+      @provider.destroy_instance self
+    end
+
+    private
+
+      def require_attribute(name)
+        if @attributes[name].nil?
+          raise MissingAttributeError.new(name)
+        end
+      end
+
+  end
+end

data/lib/asteroid/instance/command.rb

@@ -0,0 +1,146 @@
+
+module Asteroid
+  class Instance
+
+    def eval_command(cmd, env = nil)
+      env ||= template_data
+      cmd = Template.new(:erb).render(cmd, env)
+      cmd, *rest = cmd.split(" ")
+      case cmd.to_sym
+      when :run
+        self.ssh # reconnect
+        command_run(rest.first, env)
+      when :upload
+        from, to, _ = rest
+        command_upload(from, to, env)
+      when :"upload-private-key"
+        name, _ = rest
+        command_upload_private_key(name, env)
+      when :exec
+        script = rest.join(" ")
+        command_exec(script, env)
+      when :config
+        set_or_get, var, val, _ = rest
+        command_config(set_or_get, var, val)
+      else
+        if server.commands[cmd]
+          command_command(cmd, rest, env)
+        else
+          binding.pry
+        end
+      end
+    end
+
+    def template_data
+      {
+        instance: self, server: server
+      }
+    end
+
+    def command_command(cmd, args, env)
+      env ||= template_data
+      command = server.commands[cmd]
+
+      env = if command["args"]
+        command["args"].inject({}) do |r, k|
+          r[k] = args.shift
+          r
+        end
+      end
+
+      env = template_data.merge({
+        args: env
+      })
+
+      command["steps"].map do |step|
+        eval_command step, env
+      end.last
+    end
+
+    def command_run_yml_script(yml_script, env = nil)
+      env ||= template_data
+      filename = File.join(Asteroid::Config.script_dir, '/', yml_script)
+      script = File.read(filename)
+      yml = Template.new(:erb).render(script, env)
+      data = YAML::load yml
+      unless data["steps"]
+        raise "No steps in #{filenbame}"
+      else
+        data["steps"].each do |step|
+          eval_command step, env
+        end
+      end
+    end
+
+    def aster_environment
+      @aster_environment ||= Aster::Environment.new.tap do |e|
+        e.define_function :run, [] do |arguments|
+          binding.pry
+        end
+
+        e.define_function :exec, [] do |arguments|
+          binding.pry
+        end
+      end    
+    end
+
+    def command_run_aster_script(aster_script, env = nil)
+      filename = File.join(Asteroid::Config.script_dir, '/', aster_script)
+      script = File.read(filename)
+      aster_environment.eval script
+    end
+
+    def command_run(script_name, env = nil)
+      env ||= template_data
+      script = Script.named(script_name)
+
+      if script.nil?
+        raise "No script named #{script_name}"
+      end
+      
+      # Return early if we're running a script
+      if script.yml?
+        # TODO: send the fucking script obj
+        command_run_yml_script(script_name)
+        return 
+      elsif script.aster?
+        command_run_aster_script(script_name)
+        return
+      end
+
+
+      if script.template?
+        script.set_data env
+      end
+
+      rendered_script = script.render
+      puts rendered_script
+      puts self.ssh_exec rendered_script
+    end
+
+    def command_upload(from, to, env = nil)
+      env ||= template_data
+      from = ConfigFile.new(from)
+
+      if from.template?
+        from.set_data env
+      end
+
+      puts from.filename
+      self.scp.upload! from.filename, to
+    end
+
+    def command_exec(command, env = nil)
+      self.ssh_exec command
+    end
+
+    def command_config(set_or_get, var, val)
+      if set_or_get.to_s == "set"
+        self.config_set(var, val)
+      elsif set_or_get == "get"
+        self.config_get(var)
+      end      
+    end
+
+  end
+end

data/lib/asteroid/instance/scp.rb

@@ -0,0 +1,17 @@
+require 'net/scp'
+
+module Asteroid
+  class Instance
+    def scp
+      if @scp && (@scp.session.transport.port.to_s != self["ssh.port"] || (@scp.session.transport.options[:user] != self["login.username"]))
+        @scp = nil
+      end
+      @scp ||= Net::SCP.start(
+        ip_address, 
+        self["login.username"],
+        port: self["ssh.port"].to_i,
+        :keys => [server.ssh_key_filename]
+      )
+    end
+  end  
+end

data/lib/asteroid/instance/ssh.rb

@@ -0,0 +1,29 @@
+require 'net/ssh'
+
+module Asteroid
+  class Instance
+
+    def ssh_exec(command)
+      ssh.exec!(command) do |channel, stream, data|
+        if stream == :stdout
+          puts data
+        else
+          puts data
+        end
+      end
+    end
+
+    def ssh
+      if @ssh && (@ssh.transport.port.to_s != self["ssh.port"] || (@ssh.transport.options[:user] != self["login.username"]))
+        @ssh = nil
+      end
+      @ssh ||= Net::SSH.start(
+        ip_address, 
+        self["login.username"], 
+        port: self["ssh.port"].to_i,
+        :keys => [server.ssh_key_filename]
+      )
+    end
+    
+  end  
+end

data/lib/asteroid/instance/vars.rb

@@ -0,0 +1,45 @@
+
+
+module Asteroid
+
+  class Instance
+
+    def [](k)
+      val = config_get k
+      val.nil? ? server_defaults[k] : val
+    end
+
+    def []=(k, v)
+      config_set k, v
+    end
+
+    def config_get(k)
+      data = load_config_data
+      data && data[k]
+    end
+
+    def config_set(k, v)
+      data = load_config_data
+      data[k] = v
+      save_config_data data
+      v
+    end
+
+    def config_filename
+      File.join(Asteroid::Config.instance_config_dir, "/instance_#{@id}.yml")
+    end
+
+    def load_config_data
+      begin
+        YAML::load_file config_filename
+      rescue
+        {}
+      end
+    end
+
+    def save_config_data(data)
+      File.open(config_filename, 'w') {|f| f.write data.to_yaml }
+    end
+  end
+  
+end

data/lib/asteroid/provider.rb

@@ -0,0 +1,36 @@
+
+require_relative './provider/abstract'
+require_relative './provider/digital_ocean'
+require_relative './provider/virtual_box'
+require_relative './provider/mock'
+
+module Asteroid
+
+  class ProviderProxy
+
+    def method_missing(m, *args, &block)
+      Config.providers.map do |p|
+        p.send(m, *args, &block)
+      end.flatten
+    end
+
+  end
+
+  module Provider
+    
+    def self.all
+      ProviderProxy.new
+    end
+
+  end
+
+  class Config
+    class << self
+      attr_accessor :providers
+      def providers
+        @providers ||= []
+      end
+    end
+  end
+
+end

data/lib/asteroid/provider/abstract.rb

@@ -0,0 +1,37 @@
+# :name=>"web-1c5c2972",
+# :image_id=>3101918,
+# :size_id=>66,
+# :region_id=>4,
+# :backups_active=>false,
+# :ip_address=>"107.170.109.79",
+# :private_ip_address=>"10.128.197.52",
+# :locked=>false,
+# :status=>"active",
+# :created_at=>"2014-04-12T20:44:53Z"}
+
+module Asteroid
+  module Provider
+    class Abstract
+
+      def required_instance_attributes
+        []
+      end
+
+      def initialize(config = {})
+        @config = config
+      end
+
+      def self.type
+        self.to_s.split('::').last.underscore.to_sym
+      end
+
+      def instances
+        
+      end
+      
+      def destroy_instance(instance)
+      end
+
+    end
+  end
+end

data/lib/asteroid/provider/digital_ocean.rb

@@ -0,0 +1,66 @@
+module Asteroid
+  module Provider
+    class DigitalOcean < Abstract
+
+      def initialize(config = {})
+        @config = config
+        Digitalocean.client_id  = config[:client_id]
+        Digitalocean.api_key    = config[:api_key]
+      end
+
+      def sizes
+        Digitalocean::Size.all.sizes.map do |d|
+          d.marshal_dump.merge(
+            provider: self
+          )
+        end
+      end
+
+      def instances
+        response = Digitalocean::Droplet.all
+        response.droplets.map do |d|
+          d.marshal_dump.merge(
+            provider: self
+          )
+        end
+      end
+
+      def create_instance(server)
+        instance = Digitalocean::Droplet.create(
+          name: server.instance_name, 
+          size_id: server.attributes[:size_id], 
+          image_id: server.attributes[:image_id], 
+          region_id: server.attributes[:region_id], 
+          ssh_key_ids: server.attributes[:ssh_key_ids],
+          private_networking: true
+        )
+
+        if instance.status == "OK"
+          Instance.new instance.droplet.merge(provider: self)
+        else
+          nil
+        end
+      end
+   
+      def destroy_instance(instance)
+        Digitalocean::Droplet.destroy instance.id
+      end
+
+      def ssh_keys
+        response = Digitalocean::SshKey.all
+        response.ssh_keys.map do |d|
+          d.marshal_dump.merge(
+            provider: self
+          )
+        end
+      end
+
+      def create_ssh_key(config)
+      end
+
+      def reboot_instance(instance)
+      end
+
+    end
+  end
+end