Don't mix deploy actions and site update/create actions

Author: biilmann

README.md

@@ -132,17 +132,13 @@ Creating a site from a zip file:
 site = bitballoon.sites.create(:zip => "/tmp/my-site.zip")
 ```
 
-Both methods will create the site and upload the files. The site will then be processing.
+Both methods will create the site and upload the files to a new deploy.
 
-```ruby
-site.state == "processing"
-site.processing? == true
-```
-
-Refresh a site to update the state:
+Creating a site with a dir or a zip is actually a shortcut for something like this:
 
 ```ruby
-    site.refresh
+site = bitballoon.sites.create(:name => "unique-site-subdomain", :custom_domain => "www.example.com")
+deploy = site.deploys.create(:dir => "path/to/my-site")
 ```
 
 Use `wait_for_ready` to wait until a site has finished processing.
@@ -153,20 +149,29 @@ site.wait_for_ready
 site.state == "ready"
 ```
 
+This also works on a specific deploy, and you can pass in a block to execute after each polling action:
+
+```ruby
+deploy = site.deploys.create(:dir => "/tmp/my-site")
+deploy.wait_for_ready do |deploy|
+  puts "Current state: #{deploy.state}"
+end
+```
+
 Redeploy a site from a dir:
 
 ```ruby
 site = bitballoon.sites.get(site_id)
-site.update(:dir => "/tmp/my-site")
-site.wait_for_ready
+deploy = site.deploys.create(:dir => "/tmp/my-site")
+deploy.wait_for_ready
 ```
 
 Redeploy a site from a zip file:
 
 ```ruby
 site = bitballoon.sites.get(site_id)
-site.update(:zip => "/tmp/my-site.zip")
-site.wait_for_ready
+deploy = site.deploys.create(:zip => "/tmp/my-site.zip")
+deploy.wait_for_ready
 ```
 
 Update the name of the site (its subdomain), the custom domain and the notification email for form submissions:
@@ -195,7 +200,7 @@ Access a specific deploy
 
 ```ruby
 site = bitballoon.sites.get(site_id)
-site.deploys.get(id)
+deploy = site.deploys.get(id)
 ```
 
 Restore a deploy (makes it the current live version of the site)
@@ -204,6 +209,12 @@ Restore a deploy (makes it the current live version of the site)
 site.deploys.get(id).restore
 ```
 
+Create a new deploy
+
+```ruby
+deploy = site.deploys.create(:dir => "/tmp/my-site")
+```
+
 Users
 =====
 
@@ -427,4 +438,3 @@ Revoke access token:
 ```ruby
 bitballoon.access_tokens.get("token-string").destroy
 ```
-

bin/bitballoon

@@ -65,4 +65,4 @@ opts = Slop.parse do
       puts "Site deployed: #{site.url}"
     end
   end
-end
+end

lib/bitballoon/collection_proxy.rb

@@ -45,4 +45,4 @@ def path
       [prefix, self.class.path].compact.join("/")
     end
   end
-end
+end

lib/bitballoon/deploy.rb

@@ -4,10 +4,54 @@ class Deploy < Model
            :admin_url, :deploy_url, :screenshot_url, :created_at, :updated_at,
            :user_id, :required
 
+    def upload_dir(dir)
+      return unless state == "uploading"
+
+      shas = Hash.new { [] }
+      glob = ::File.join(dir, "**", "*")
+
+      Dir.glob(glob) do |file|
+        next unless ::File.file?(file)
+        pathname = ::File.join("/", file[dir.length..-1])
+        next if pathname.match(/(^\/?__MACOSX\/|\/\.)/)
+        sha = Digest::SHA1.hexdigest(::File.read(file))
+        shas[sha] = shas[sha] + [pathname]
+      end
+
+      (required || []).each do |sha|
+        shas[sha].each do |pathname|
+          client.request(:put, ::File.join(path, "files", URI.encode(pathname)), :body => ::File.read(::File.join(dir, pathname)), :headers => {"Content-Type" => "application/octet-stream"})
+        end
+      end
+
+      refresh
+    end
+
+    def wait_for_ready(timeout = 900)
+      start = Time.now
+      while !(ready?)
+        sleep 5
+        refresh
+        puts "Got state: #{state}"
+        raise "Error processing site: #{error_message}" if error?
+        yield(self) if block_given?
+        raise "Timeout while waiting for ready" if Time.now - start > timeout
+      end
+      self
+    end
+
+    def ready?
+      state == "ready"
+    end
+
+    def error?
+      state == "error"
+    end
+
     def restore
       response = client.request(:post, ::File.join(path, "restore"))
       process(response.parsed)
       self
     end
   end
-end
+end

lib/bitballoon/deploys.rb

@@ -3,5 +3,51 @@
 module BitBalloon
   class Deploys < CollectionProxy
     path "/deploys"
+
+    def create(attributes)
+      response = nil
+      if attributes[:dir]
+        response = client.request(:post, path, :body => {:files => inventory(attributes[:dir])})
+      elsif attributes[:zip]
+        response = client.request(:post, path, :body => ::File.read(attributes[:zip]), :headers => {"Content-Type" => "application/zip"})
+      else
+        raise "Need dir or zip to create a deploy"
+      end
+      Deploy.new(client, response.parsed)
+
+      #
+      # site_id = attributes.delete(:id)
+      # path    = site_id ? "/sites/#{site_id}" : "/sites"
+      # method  = site_id ? :put : :post
+      # if attributes[:dir]
+      #   dir = attributes.delete(:dir)
+      #   response = client.request(method, path, :body => JSON.generate(attributes.merge(:files => inventory(dir))), :headers => {"Content-Type" => "application/json"})
+      #   Site.new(client, response.parsed).tap do |site|
+      #     deploy = Deploy.new(client, :id => site.deploy_id, :required => site.required, :state => site.state)
+      #     puts "Uploading dir"
+      #     deploy.upload_dir(dir)
+      #     site.refresh
+      #   end
+      # elsif attributes[:zip]
+      #   zip = attributes.delete(:zip)
+      #   ::File.open(zip) do |file|
+      #     response = client.request(method, path, :body => attributes.merge(
+      #       :zip => Faraday::UploadIO.new(file, 'application/zip')
+      #     ))
+      #     Site.new(client, response.parsed)
+      #   end
+      # end
+    end
+
+    private
+    def inventory(dir)
+      files = {}
+      Dir[::File.join(dir, "**", "*")].each do |file|
+        next unless ::File.file?(file)
+        path = ::File.join("/", file[dir.length..-1])
+        files[path] = Digest::SHA1.hexdigest(::File.read(file))
+      end
+      files
+    end
   end
-end
+end

lib/bitballoon/site.rb

@@ -4,32 +4,8 @@
 module BitBalloon
   class Site < Model
     fields :id, :state, :premium, :claimed, :name, :custom_domain, :url,
-           :admin_url, :deploy_url, :screenshot_url, :created_at, :updated_at,
-           :password, :notification_email, :user_id, :required, :error_message
-
-    def upload_dir(dir)
-      return unless state == "uploading"
-
-      shas = Hash.new { [] }
-      glob = ::File.join(dir, "**", "*")
-
-      Dir.glob(glob) do |file|
-        next unless ::File.file?(file)
-        pathname = ::File.join("/", file[dir.length..-1])
-        next if pathname.match(/(^\/?__MACOSX\/|\/\.)/)
-        sha = Digest::SHA1.hexdigest(::File.read(file))
-        shas[sha] = shas[sha] + [pathname]
-      end
-
-
-      (required || []).each do |sha|
-        shas[sha].each do |pathname|
-          client.request(:put, ::File.join(path, "files", URI.encode(pathname)), :body => ::File.read(::File.join(dir, pathname)), :headers => {"Content-Type" => "application/octet-stream"})
-        end
-      end
-
-      refresh
-    end
+           :admin_url, :deploy_id, :deploy_url, :screenshot_url, :created_at, :updated_at,
+           :password, :notification_email, :user_id, :error_message, :required
 
     def ready?
       state == "current"
@@ -39,25 +15,19 @@ def error?
       state == "error"
     end
 
-    def wait_for_ready(timeout = 900)
-      start = Time.now
-      while !(ready?)
-        sleep 5
-        refresh
-        raise "Error processing site: #{error_message}" if error?
-        yield(self) if block_given?
-        raise "Timeout while waiting for ready" if Time.now - start > timeout
-      end
+    def wait_for_ready(timeout = 900, &block)
+      deploy = deploys.get(deploy_id)
+      raise "Error fetching deploy #{deploy_id}" unless deploy
+      deploy.wait_for_ready(timeout, &block)
       self
     end
 
     def update(attributes)
+      response = client.request(:put, path, :body => mutable_attributes(attributes))
+      process(response.parsed)
       if attributes[:zip] || attributes[:dir]
-        site = collection.new(client).create(attributes.merge(:id => id))
-        process(site.attributes)
-      else
-        response = client.request(:put, path, :body => mutable_attributes(attributes))
-        process(response.parsed)
+        deploy = deploys.create(attributes)
+        self.deploy_id = deploy.id
       end
       self
     end

lib/bitballoon/sites.rb

@@ -6,35 +6,13 @@ class Sites < CollectionProxy
     path "/sites"
 
     def create(attributes = {})
-      site_id = attributes.delete(:id)
-      path    = site_id ? "/sites/#{site_id}" : "/sites"
-      method  = site_id ? :put : :post
-      if attributes[:dir]
-        dir = attributes.delete(:dir)
-        response = client.request(method, path, :body => JSON.generate(attributes.merge(:files => inventory(dir))), :headers => {"Content-Type" => "application/json"})
-        Site.new(client, response.parsed).tap do |site|
-          site.upload_dir(dir)
+      response = client.request(:post, path, :body => Site.new(client, {}).send(:mutable_attributes, attributes))
+      Site.new(client, response.parsed).tap do |site|
+        if attributes[:zip] || attributes[:dir]
+          deploy = site.deploys.create(attributes)
+          site.deploy_id = deploy.id
         end
-      elsif attributes[:zip]
-        zip = attributes.delete(:zip)
-        ::File.open(zip) do |file|
-          response = client.request(method, path, :body => attributes.merge(
-            :zip => Faraday::UploadIO.new(file, 'application/zip')
-          ))
-          Site.new(client, response.parsed)
-        end
-      end
-    end
-
-    private
-    def inventory(dir)
-      files = {}
-      Dir[::File.join(dir, "**", "*")].each do |file|
-        next unless ::File.file?(file)
-        path = ::File.join("/", file[dir.length..-1])
-        files[path] = Digest::SHA1.hexdigest(::File.read(file))
       end
-      files
     end
   end
-end
+end