fastly 0.5

data/lib/fastly/backend.rb

@@ -0,0 +1,99 @@
+class Fastly
+  # An individual host you want to serve assets off
+  class Backend < BelongsToServiceAndVersion
+    attr_accessor :service_id, :name, :address, :ipv4, :ipv6, :hostname, :use_ssl, :client_cert, :port, 
+                  :connect_timeout, :first_byte_timeout, :between_bytes_timeout, :error_threshold, :max_conn, :weight, :comment
+
+    ## 
+    # :attr: service_id
+    # 
+    # The id of the service this belongs to.
+    # 
+
+    ## 
+    # :attr: version
+    # 
+    # The number of the version this belongs to.
+    # 
+
+    ## 
+    # :attr: name
+    # 
+    # The name of this backend.
+    # 
+
+    ## 
+    # :attr: address
+    # 
+    # A magic field - will automagically be set to whichever of ipv4, ipv6 or hostname is currently set.
+    # 
+    # Conversely if you set the address field then the correct field from ipv4, ipv6 or hostname will be set.
+    # 
+
+    ## 
+    # :attr: ipv4
+    # 
+    # the ipv4 address of the host to serve assets (this, hostname or ipv6 must be set)
+    # 
+
+    ## 
+    # :attr: ipv6
+    # 
+    # the ipv6 address of the host to serve assets (this, hostname or ipv4 must be set)
+    # 
+
+    ## 
+    # :attr: hostname
+    # 
+    # the hostname to serve assets from (this, ipv4 or ipv6 must be set)
+    # 
+
+    ## 
+    # :attr: port
+    # 
+    # the port to connect to (default 80)
+    # 
+
+    ## 
+    # :attr: use_ssl
+    # 
+    # whether to use ssl to get to the backend (default 0 i.e false)
+    # 
+
+    ## 
+    # :attr: connect_timeout
+    # 
+    # how long in milliseconds to wait for a connect before declaring the backend out of rotation (default 1,000)
+    # 
+
+    ## 
+    # :attr: first_byte_timeout
+    # 
+    # how long in milliseconds to wait for the first bytes before declaring the host out of rotation (default 15,000)
+    # 
+
+    ## 
+    # :attr: between_bytes_timeout
+    # 
+    # how long in milliseconds to wait between bytes before declaring the backend out of rotation (default 10,000)
+    # 
+
+    ## 
+    # :attr: error_threshold
+    # 
+    # how many errors before declaring the backend out of rotation (default 0, 0 meaning turned off)
+    # 
+
+    ## 
+    # :attr: max_conn
+    # 
+    # the maximum number of connections to this backend (default 20)
+    # 
+
+    ## 
+    # :attr: weight
+    # 
+    # the weight assigned to this backend (default 100)
+
+  end
+end

data/lib/fastly/base.rb

@@ -0,0 +1,62 @@
+
+class Fastly
+  # Base class for all Fastly objects
+  class Base # :nodoc: all
+    attr_accessor :fetcher
+    
+    def initialize(opts, fetcher)
+      @keys = []
+      opts.each do |key,val|
+        next unless self.respond_to? "#{key}="
+        self.send("#{key}=", val)
+        @keys.push(key)
+      end
+      self.fetcher = fetcher
+     end
+     
+     # Save this object
+     def save!
+       fetcher.update(self.class, self)
+     end
+
+     # Delete this object
+     def delete!
+       fetcher.delete(self.class, self)
+     end
+     
+     ##
+     # :nodoc:
+     def as_hash
+       ret = {}
+       @keys.each do |key|
+         ret[key] = self.send("#{key}") unless key =~ /^_/;
+       end
+       ret
+     end
+
+     def self.path
+       self.to_s.downcase.split("::")[-1]
+     end
+     
+     def self.get_path(id)
+       "/#{path}/#{id}"
+     end
+     
+     def self.post_path(opts={})
+       "/#{path}"
+     end
+     
+     def self.list_path(opts={})
+       post_path(opts)
+     end
+     
+     def self.put_path(obj)
+       get_path(obj.id)
+     end
+     
+     def self.delete_path(obj)
+       put_path(obj)
+     end
+     
+  end
+end

data/lib/fastly/belongs_to_service_and_version.rb

@@ -0,0 +1,42 @@
+class Fastly
+  class BelongsToServiceAndVersion < Base
+    # Return the Service object this belongs to
+    def service
+      @service ||= fetcher.get(Fastly::Service, service_id)
+    end
+    
+    # Set the Version object this belongs to
+    def version=(version)
+      @version = version
+    end
+    
+    # Get the Version object this belongs to
+    def version
+      @version_obj ||= fetcher.get(Fastly::Version, service_id, version_number)
+    end
+    
+    # Get the number of the Version this belongs to
+    def version_number
+      @version
+    end
+    
+    private
+    
+    def self.get_path(service, version, name)
+      "/service/#{service}/version/#{version}/#{path}/#{name}"
+    end
+    
+    def self.post_path(opts)
+    "/service/#{opts[:service_id]}/version/#{opts[:version]}/#{path}"
+    end
+    
+    def self.put_path(obj)
+      get_path(obj.service_id, obj.version_number,obj.name)
+    end
+    
+    def self.delete_path(obj)
+      put_path(obj)
+    end
+    
+  end
+end

data/lib/fastly/client.rb

@@ -0,0 +1,160 @@
+require 'net/http'
+require 'net/https'
+require 'json'
+require 'cgi'
+require 'pp'
+require 'uri'
+
+class Fastly
+    # The UserAgent to communicate with the API
+    class Client #:nodoc: all
+        begin 
+            require 'curb-fu'
+            CURB_FU=true
+        rescue LoadError
+            CURB_FU=false
+        end
+
+        attr_accessor :http, :api_key, :user, :password, :cookie
+
+        def initialize(opts)
+            [:api_key, :user, :password].each do |key|
+                self.send("#{key}=", opts[key]) if opts.has_key?(key)
+            end
+            base   = opts[:base_url]      || "https://api.fastly.com"
+            port   = opts[:base_port]     || 80
+            uri    = URI.parse(base)
+            scheme = uri.scheme
+            host   = uri.host
+            curb = opts.has_key?(:use_curb) ? !!opts[:use_curb] && CURB_FU : CURB_FU
+            self.http = curb ? Fastly::Client::Curl.new(host, port) : Net::HTTP.new(host, port)
+            self.http.use_ssl = (scheme == "https")
+            return self unless fully_authed?
+
+            # If we're fully authed (i.e username and password ) then we need to log in
+            resp = self.http.post('/login', make_params(:user => user, :password => password))
+            raise Fastly::Unauthorized unless resp.success?
+            self.cookie = resp['set-cookie']
+            content     = JSON.parse(resp.body)
+            #return self, content['user'], content['content']
+            self
+        end
+
+
+        def authed?
+            !api_key.nil? || fully_authed?
+        end
+
+        # Some methods require full username and password rather than just auth token
+        def fully_authed?
+            !(user.nil? || password.nil?)
+        end
+
+        def get(path, params={})
+            path += "?"+make_params(params) unless params.empty? 
+            resp  = self.http.get(path, headers)
+            return nil if 404 == resp.status
+            raise Fastly::Error, resp.message unless resp.success?
+            JSON.parse(resp.body)
+        end
+
+        def post(path, params={})
+            post_and_put(:post, path, params)
+        end
+
+        def put(path, params={})
+            post_and_put(:put, path, params)
+        end
+
+        def delete(path)
+            resp  = self.http.delete(path, headers)
+            return resp.success?
+        end
+
+        private
+
+        def post_and_put(method, path, params={})
+            query = make_params(params)
+            resp  = self.http.send(method, path, query, headers.merge( 'Content-Type' =>  "application/x-www-form-urlencoded"))
+            raise Fastly::Error, resp.message unless resp.success?
+            JSON.parse(resp.body)
+        end
+
+        def headers
+            (fully_authed? ? { 'Cookie' => cookie } : { 'X-Fastly-Key' => api_key }).merge( 'Content-Accept' => 'application/json')
+        end
+
+        def make_params(params)
+            params.map { |key,val| 
+                next if val.nil?
+                unless val.is_a?(Hash)
+                    "#{CGI.escape(key.to_s)}=#{CGI.escape(val.to_s)}"
+                else 
+                    val.map { |sub_key, sub_val|
+                        new_key = "#{key}[#{sub_key}]"
+                        "#{CGI.escape(new_key)}=#{CGI.escape(sub_val.to_s)}"
+                    } 
+                end
+            }.flatten.delete_if { |v| v.nil? }.join("&")
+        end
+        
+        # :nodoc: all
+        class Curl
+            attr_accessor :host, :port, :protocol
+
+            def initialize(host, port=80)
+                self.host     = host
+                self.port     = port
+                self.protocol = 'https'
+            end
+
+            def get(path, headers={})
+                CurbFu.get({ :host => host, :port => port, :path => path, :headers => headers, :protocol => protocol })
+            end
+
+            def post(path, params, headers={})
+                CurbFu.post({ :host => host, :port => port, :path => path, :headers => headers, :protocol => protocol }, params)
+            end
+
+            def put(path, params, headers={})
+                CurbFu.put({ :host => host, :port => port, :path => path, :headers => headers, :params => params, :protocol => protocol }, params)
+            end
+
+            def delete(path, headers={})
+                CurbFu.delete({ :host => host, :port => port, :path => path, :headers => headers, :protocol => protocol })
+            end
+
+            def use_ssl=(ssl)
+                self.protocol = ssl ? 'https' : 'http'
+            end
+        end
+    end
+end
+
+# :nodoc: all
+class Net::HTTPResponse 
+    def success?
+        return Net::HTTPSuccess === self
+    end
+
+    def status
+        return self.code.to_i
+    end
+end
+
+
+
+# :nodoc: all
+class CurbFu::Response::Base 
+    def get_fields(key)
+        if ( match = @headers.find{|k,v| k.downcase == key.downcase} )
+            [match.last].flatten
+        else
+            []
+        end
+    end
+
+    def [](key)
+        get_fields(key).last
+    end
+end

data/lib/fastly/customer.rb

@@ -0,0 +1,26 @@
+class Fastly
+  # A Customer account
+  class Customer < Base
+    attr_accessor :id, :name, :owner_id
+
+    ##
+    # :attr: id
+    # 
+    # The id of this customer
+
+    ## 
+    # :attr: name
+    # 
+    # The name of this customer
+
+    ## 
+    # :attr: owner_id
+    # 
+    # The id of the user that owns this customer
+
+    # Return a user object representing the owner of this Customer
+    def owner
+      self.fetcher.get(User,self.owner_id)
+    end
+  end
+end

data/lib/fastly/director.rb

@@ -0,0 +1,47 @@
+class Fastly
+  # A logical collection of backends - for example all the asset servers in one data center
+  class Director < BelongsToServiceAndVersion
+    attr_accessor :service_id, :name, :type, :comment, :retries, :capacity, :quorom
+
+    ## 
+    # :attr: service
+    # 
+    # The id of the service this belongs to.
+    # 
+
+    ## 
+    # :attr: version
+    # 
+    # The number of the version this belongs to.
+    # 
+
+    ## 
+    # :attr: name
+    # 
+    # The domain name of this domain
+    # 
+
+    ## 
+    # :attr: type
+    # 
+    # what kind of Load Balancer group (currently always 1 meaning random)
+    # 
+
+    ## 
+    # :attr: retries
+    # 
+    # how many backends to search if it fails (default 5)
+    # 
+
+    ## 
+    # :attr: quorum
+    # 
+    # the percentage of capacity that needs to be up for a director to be considered up (default 75)
+    # 
+
+    ## 
+    # :attr: comment 
+    # 
+    # a free form comment field
+  end
+end

data/lib/fastly/domain.rb

@@ -0,0 +1,29 @@
+class Fastly
+  # A domain name you want to map to a service
+  class Domain < BelongsToServiceAndVersion
+    attr_accessor :service_id, :name, :comment
+
+    ## 
+    # :attr: service_id
+    # 
+    # The id of the service this belongs to.
+    # 
+
+    ## 
+    # :attr: version
+    # 
+    # The number of the version this belongs to.
+    # 
+
+    ## 
+    # :attr: name
+    # 
+    # The domain name of this domain
+    # 
+
+    ## 
+    # :attr: comment 
+    # 
+    # a free form comment field
+  end
+end