skypager 0.0.2

data/lib/skypager/site.rb

@@ -0,0 +1,208 @@
+module Skypager
+  class Site
+    class << self
+      def directory
+        Skypager.config.sites_directory
+      end
+    end
+
+    attr_accessor :options,
+                  :name,
+                  :config
+
+    def initialize(name, options = {})
+      @name     = name.to_s.downcase
+      @options  = options
+      @config   = self.class.directory[@name] || {
+        name: @name
+      }
+    end
+
+    def set attribute, value
+      @config[attribute.to_sym] = value
+      save!
+      self
+    end
+
+    def get! attribute
+      val = get(attribute)
+
+      if val.nil? || val.to_s.length == 0
+        nil
+      else
+        val
+      end
+    end
+
+    def get attribute
+      @config[attribute.to_sym]
+    end
+
+    def hostname= value
+      set(:hostname, value)
+    end
+
+    def hostname
+      custom_domain || bucket_hostname
+    end
+
+    def bucket_hostname
+      "#{@config[:name] || @name}.#{ Skypager.config.domain }"
+    end
+
+    def bucket(create=false)
+      return @bucket if @bucket
+
+      b = Skypager.amazon.find_bucket_by_name(bucket_hostname) rescue nil
+
+      if create && !b
+        b = Skypager.amazon.create_bucket(bucket_hostname)
+      end
+
+      @bucket = b
+    end
+
+    def deploy(build_dir)
+      target = bucket || Skypager.amazon.s3_bucket
+
+      upload = lambda do |node|
+        next if node.to_s == ".DS_Store"
+
+        if node.directory?
+          Array(node.children).each(&upload)
+        elsif node.file?
+          rel = node.relative_path_from(build_dir).to_s
+          puts "Deploying #{ rel }"
+          target.files.create(key: rel, body: File.open(node), public: true)
+        end
+      end
+
+      build_dir.children.each(&upload)
+    end
+
+    def use_cdn?
+      get(:use_cdn) == true || get(:use_cdn) == "yes" || get(:use_cdn) == "true"
+    end
+
+    def paths_to_invalidate(app)
+      app.sitemap.resources.map {|r| "/#{r.request_path}" }
+    end
+
+    def after_setup
+      if use_cdn? && !has_cdn?
+        Skypager.amazon.create_cdn_for(self)
+      end
+
+      if Skypager.config.dnsimple_setup?
+        setup_cname() unless custom_domain?
+      else
+        puts "You will need to setup the DNS for this bucket yourself."
+
+        if has_cdn?
+          puts "You will want to configure the DNS for #{ custom_domain }"
+          puts "Create a CNAME and point to #{ cname_value }"
+        else
+          puts "Create a CNAME for #{ cname_value } on #{ Skypager.config.domain } and point to #{ bucket_host }"
+        end
+      end
+    end
+
+    def custom_domain?
+      get!(:custom_domain)
+    end
+
+    def deploy_options_config_string
+      custom_domain = get!(:custom_domain)
+
+      cfg = []
+
+      if custom_domain.length > 0
+        cfg.push(":custom_domain => '#{ custom_domain }'")
+        cfg.push(":use_cdn => true")
+      else
+        cfg.push(":domain => '#{ Skypager.config.domain }'")
+      end
+
+      cfg.push(":bucket_name => '#{ bucket_name }'")
+
+      "\ndeploy_to(:amazon, #{cfg.join(", ")})\n"
+    end
+
+    def bucket_key
+      fetch(:bucket_key) { bucket && bucket.key }
+    end
+
+    def bucket_name
+      bucket_key
+    end
+
+    def custom_domain
+      value = get(:custom_domain).to_s
+      value if value.length > 0
+    end
+
+    def fetch(key, &block)
+      @config.fetch(key, &block)
+    end
+
+    def bucket_url
+      @bucket_url ||= fetch(:bucket_url) { Skypager.amazon.website_url_for(bucket) }
+    end
+
+    def bucket_host
+      @bucket_host ||= fetch(:bucket_host) { URI.parse("http://#{ bucket_url }").host }
+    end
+
+    def setup_cname
+      puts "Creating an alias for #{ cname_value } to #{ bucket_host }"
+      Skypager.dns.setup_cname(cname_value, bucket_host)
+    end
+
+    def cname_value
+      if custom_domain && has_cdn?
+        cdn.domain
+      else
+        name
+      end
+    end
+
+    def description
+      "#{ name }.#{ Skypager.config.domain }"
+    end
+
+    def has_cdn?
+      @cdn_distribution ||= Skypager.amazon.cdn.distributions.find do |cdn|
+        cdn.comment == description
+      end
+    end
+
+    def cdn
+      @cdn ||= Skypager.amazon.cdn.distributions.find do |cdn|
+        cdn.comment == description
+      end
+    end
+
+    def aliases
+      if custom_domain
+        [custom_domain, "www.#{ custom_domain }"]
+      end
+    end
+
+    def delete!
+      directory = self.class.directory
+      directory.delete(name)
+      Skypager.config.set :sites_directory, directory
+    end
+
+    def save!
+      directory = self.class.directory
+      directory[name] = to_config
+      Skypager.config.set :sites_directory, directory
+    end
+
+    def to_config
+      @config
+    end
+
+  end
+end

data/lib/skypager/sync.rb

@@ -0,0 +1,23 @@
+module Skypager
+  module Sync
+    def self.sync_dropbox_path(path, options={})
+      dropbox.sync_path(path, options)
+    end
+
+    def self.amazon(options={})
+      require 'skypager/sync/amazon'
+      Skypager::Sync::Amazon.client
+    end
+
+    def self.google(options={})
+      require 'skypager/sync/google'
+      Skypager::Sync::Google.client
+    end
+
+    def self.dropbox(options={})
+      require 'skypager/sync/dropbox'
+      Skypager::Sync::Dropbox.client(options)
+    end
+  end
+end
+

data/lib/skypager/sync/amazon.rb

@@ -0,0 +1,171 @@
+module Skypager
+  module Sync
+    class Amazon
+      include Singleton
+
+      require 'fog'
+
+      def aws_access_key_id
+        options[:aws_access_key_id] || options[:access_key_id] || Skypager.config.aws_access_key_id
+      end
+
+      def aws_secret_access_key
+        options[:aws_secret_access_key] || options[:secret_access_key] || Skypager.config.aws_secret_access_key
+      end
+
+      def storage
+        @storage ||= Fog::Storage.new({
+          provider: 'AWS',
+          aws_access_key_id: aws_access_key_id,
+          aws_secret_access_key: aws_secret_access_key,
+          path_style: true
+        })
+      end
+
+      def cdn
+        @cdn ||= Fog::CDN.new({
+          provider: 'AWS',
+          aws_access_key_id: aws_access_key_id,
+          aws_secret_access_key: aws_secret_access_key
+        })
+      end
+
+      def s3_bucket_website_url
+        if s3_bucket.is_a?(Fog::Storage::AWS::Directory)
+          website_url_for(s3_bucket)
+        end
+      end
+
+      def site_description
+        options[:description] || options[:site_name] || s3_bucket.key
+      end
+
+      # the domain, and the domain with www
+      def site_domain_aliases
+        options[:aliases]
+      end
+
+      def s3_bucket
+        if bucket_name = options[:bucket_name] || Skypager.config.get("bucket_name") || Skypager.app.deploy_options[:bucket_name]
+          if bucket = find_bucket_by_name(bucket_name)
+            return bucket
+          else
+            "There is no bucket named: #{ bucket_name }. You can create one by running 'skypager setup amazon --create-bucket=BUCKET_NAME"
+          end
+        else
+          puts "Can't determine what bucket name to use."
+        end
+      end
+
+      def create_cdn_for(site)
+        o = cdn_options(website_url: site.bucket_host,
+                        comment: site.description,
+                        aliases: site.aliases.join(","))
+
+        existing = cdn.distributions.find do |distribution|
+          distribution.comment == site.description
+        end
+
+        return existing if existing
+
+        cdn.distributions.create(o).tap do |distribution|
+          site.set distribution.domain
+        end
+      end
+
+      def cdn_options(o={})
+        {
+          enabled: true,
+          custom_origin: {
+            'DNSName'=> o.fetch(:website_url) { s3_bucket_website_url },
+            'OriginProtocolPolicy'=>'match-viewer'
+          },
+          comment: o.fetch(:description) { site_description },
+          caller_reference: Time.now.to_i.to_s,
+          cname: o.fetch(:domain_aliases) { site_domain_aliases },
+          default_root_object: 'index.html'
+        }
+      end
+
+      def self.client(options={})
+        @client ||= begin
+                      instance.with_options(options)
+                    end
+      end
+
+
+      def self.method_missing(meth, *args, &block)
+        if client.respond_to?(meth)
+          return client.send(meth, *args, &block)
+        end
+
+        super
+      end
+
+      def website_host_for(bucket_or_bucket_name)
+        URI.parse(webite_url_for(bucket_or_bucket_name)).host
+      end
+
+      def website_url_for(bucket_or_bucket_name)
+        bucket = bucket_or_bucket_name
+
+        if bucket_or_bucket_name.is_a?(String)
+          bucket = storage.directories.get(bucket_or_bucket_name)
+        end
+
+        if bucket
+          "http://#{bucket.key}.s3-website-#{ bucket.location }.amazonaws.com"
+        end
+      end
+
+      def find_or_create_bucket(bucket_name)
+        find_bucket_by_name(bucket_name) || create_bucket(bucket_name)
+      end
+
+      def find_bucket_by_name(bucket_name)
+        storage.directories.get(bucket_name) rescue nil
+      end
+
+      def create_bucket(bucket_name)
+        storage.directories.create(key: bucket_name, public: true).tap do |bucket|
+          storage.put_bucket_website(bucket_name, 'index.html', key: 'error.html')
+          storage.put_bucket_cors(bucket_name, {"AllowedOrigin"=>"*","AllowedMethod"=>"GET","AllowedHeader"=>"Authorization"})
+        end
+      end
+
+      def create_redirect_bucket(bucket_name, redirect_to_bucket_name)
+        create_bucket(redirect_to_bucket_name) unless find_bucket_by_name(redirect_to_bucket_name)
+        create_bucket(bucket_name)
+      end
+
+      def with_options(opts={})
+        options.merge!(opts)
+        self
+      end
+
+      def options
+        @options ||= {}
+      end
+
+      def has_application_keys?
+        (Skypager.config.aws_access_key_id.to_s.length > 0 && Skypager.config.aws_secret_access_key.to_s.length > 0)
+      end
+
+      def setup(options={})
+        return if has_application_keys?
+
+        unless Skypager.config.aws_access_key_id.to_s.length > 0
+          if value = options[:access_key_id] || ask("What is the AWS Access Key ID?", String)
+            Skypager.config.set 'aws_access_key_id', value
+          end
+        end
+
+        unless Skypager.config.aws_secret_access_key.to_s.length > 0
+          if value = options[:secret_access_key] || ask("What is the AWS Secret Access Key?", String)
+            Skypager.config.set 'aws_secret_access_key', value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/skypager/sync/dropbox.rb

@@ -0,0 +1,173 @@
+module Skypager
+  module Sync
+    class Dropbox
+      include Singleton
+
+      def self.method_missing(meth, *args, &block)
+        if client.respond_to?(meth)
+          return client.send(meth, *args, &block)
+        end
+
+        super
+      end
+
+      def self.client(options={})
+        @client ||= begin
+                      ::Dropbox::API::Config.app_key    = options.fetch(:dropbox_app_key) { Skypager.config.dropbox_app_key }
+                      ::Dropbox::API::Config.app_secret = options.fetch(:dropbox_app_secret) { Skypager.config.dropbox_app_secret }
+                      ::Dropbox::API::Config.mode       = options.fetch(:dropbox_app_type) { Skypager.config.dropbox_app_type }
+                      instance.with_options(options)
+                    end
+      end
+
+      def sandboxed_app?
+        entry = api.ls.first
+        entry && entry.root == "app_folder"
+      end
+
+      def api
+        @api ||= begin
+                   token = options.fetch(:token) { Skypager.config.dropbox_client_token }
+                   secret = options.fetch(:secret) { Skypager.config.dropbox_client_secret }
+                   ::Dropbox::API::Client.new(token: token  , secret: secret)
+                 end
+      end
+
+      def find(path)
+        api.find(path)
+      rescue ::Dropbox::API::Error::NotFound
+        nil
+      end
+
+      def push_from(local_path, options={})
+        path_prefix = options.fetch(:prefix)
+        root        = options[:root]
+
+        unless find(path_prefix)
+          api.mkdir(path_prefix)
+        end
+
+        uploader = lambda do |node|
+          next if node.to_s == ".DS_Store"
+
+          if node.directory?
+            Array(node.children).each(&uploader)
+          elsif node.file?
+            relative = node.relative_path_from(local_path)
+            target = "#{path_prefix}/#{relative}"
+            target = target.gsub(/^\//,'')
+            api.upload(target, node.read)
+          end
+        end
+
+        Pathname(local_path).children.each(&uploader)
+      end
+
+      def create_site_folder(folder, allow_overwrite=false)
+        found = find(folder)
+
+        unless (!found || (found && !allow_overwrite))
+          api.mkdir("/#{folder}")
+        end
+      end
+
+      def sync(local_path, remote_path, options={})
+        sync_folders(local_path, remote_path, options)
+      end
+
+      # Instructs Skypager to create a syncable folder
+      # between the local and remote path, and optionally
+      # modifies the middleman config for the site
+      def sync_folders(local_path, remote_path, options={})
+        app = options[:app]
+
+        folder = Skypager::Sync::Folder.new(local_path: local_path,
+                                            remote_path: remote_path,
+                                            app: app).synced
+
+        if !!options[:append_config] == true
+          Skypager.append_config(folder.config_line)
+        end
+
+        folder
+      end
+
+      def method_missing meth, *args, &block
+        if api.respond_to?(meth)
+          return api.send(meth, *args, &block)
+        end
+
+        super
+      end
+
+      def authorize(token, secret)
+        @api = nil if @api
+        options[:token] = token
+        options[:secret] = secret
+        self
+      end
+
+      def options
+        @options ||= {}
+      end
+
+      def with_options(opts={})
+        options.merge!(opts)
+        self
+      end
+
+      def requires_setup?
+        !(dropbox_app_key.length > 0 && dropbox_app_secret.length > 0)
+      end
+
+      def dropbox_app_key
+        Skypager.config.dropbox_app_key.to_s
+      end
+
+      def dropbox_app_secret
+        Skypager.config.dropbox_app_secret.to_s
+      end
+
+      def setup(options={})
+        if requires_setup?
+          if dropbox_app_key.length == 0
+            if answer = options[:dropbox_app_key] || ask("What is the dropbox app key?", String)
+              Skypager.config.set("dropbox_app_key", answer)
+            end
+            if answer = options[:dropbox_app_secret] || ask("What is the dropbox app secret?", String)
+              Skypager.config.set("dropbox_app_secret", answer)
+            end
+          end
+        end
+
+        raise 'Missing dropbox application values' if requires_setup?
+
+        ::Dropbox::API::Config.app_key    = Skypager.config.dropbox_app_key
+        ::Dropbox::API::Config.app_secret = Skypager.config.dropbox_app_secret
+
+        consumer = ::Dropbox::API::OAuth.consumer(:authorize)
+        request_token = consumer.get_request_token
+        puts "\nGo to this url and click 'Authorize' to get the token:"
+        puts request_token.authorize_url
+        Launchy.open(request_token.authorize_url)
+
+        query  = request_token.authorize_url.split('?').last
+        params = CGI.parse(query)
+        token  = params['oauth_token'].first
+        print "\nOnce you authorize the app on Dropbox, press enter... "
+        STDIN.gets.chomp
+
+        access_token  = request_token.get_access_token(:oauth_verifier => token)
+
+        Skypager.config.set 'dropbox_client_token', access_token.token
+        Skypager.config.set 'dropbox_client_secret', access_token.secret
+
+        puts "\nAuthorization complete!:\n\n"
+        puts "  Dropbox::API::Config.app_key    = '#{consumer.key}'"
+        puts "  Dropbox::API::Config.app_secret = '#{consumer.secret}'"
+        puts "  client = Dropbox::API::Client.new(:token  => '#{access_token.token}', :secret => '#{access_token.secret}')"
+        puts "\n"
+      end
+    end
+  end
+end