cloudfuji 0.0.37

data/.gitignore

@@ -0,0 +1,7 @@
+Gemfile.lock
+\#*#
+doc/**
+pkg/**
+coverage.data
+pkg
+.rvmrc

data/.rspec

@@ -0,0 +1,4 @@
+--format nested
+--color
+--profile
+

data/Gemfile

@@ -0,0 +1,17 @@
+#:nodoc:
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in cloudfuji.gemspec
+gemspec
+
+gem "sqlite3-ruby"
+gem "rails", "~> 3.0.7"
+
+group :development, :test do
+  # gem "webrat", "0.7.2", :require => false
+  # gem "mocha", :require => false
+  gem "rspec-rails", "~> 2.7.0"
+  gem "configatron", "> 2.8.3"
+  gem "cover_me"
+  gem "ci_reporter"
+end

data/README.md

@@ -0,0 +1,3 @@
+# Cloudfuji gem
+
+This is the secret tonic that gives Cloudfuji apps their super powers. Never take more than the recommended dose of awesomeness. 

data/Rakefile

@@ -0,0 +1,36 @@
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+require 'bundler'
+require 'ci/reporter/rake/rspec'
+Bundler::GemHelper.install_tasks
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }
+
+desc "Default: run all specs"
+task :default => :all_specs
+
+desc "Run all specs"
+task :all_specs do
+  Rake::Task["spec"].execute
+  Rake::Task["dummy_specs"].execute
+end
+
+desc "run unit tests in dummy apps"
+task :dummy_specs do
+  Dir['spec/test_apps/**/Rakefile'].each do |rakefile|
+    directory_name = File.dirname(rakefile)
+    sh <<-CMD
+      cd #{directory_name} && bundle exec rake
+    CMD
+  end
+end
+
+desc "run unit tests for gem only"
+RSpec::Core::RakeTask.new('spec') do |t|
+ t.pattern = '**/gem_spec/*_spec.rb'				  
+end
+
+
+if ENV["RAILS_ENV"] != "production"
+  require 'ci/reporter/rake/rspec'
+end

data/app/controllers/cloudfuji/data_controller.rb

@@ -0,0 +1,33 @@
+module Cloudfuji
+  class DataController < ApplicationController
+    
+    # POST /cloudfuji/data/
+    def index
+      @key = params.delete("key")
+      if ENV["CLOUDFUJI_APP_KEY"] != @key
+        respond_to do |format|
+          format.html { render :layout => false, :text => true, :status => :forbidden }
+          format.json { render :status => 401 }
+          return
+        end
+      end
+      
+      puts "Idobus Data rec'd: #{params.inspect}"
+      puts params["category"].inspect
+
+      hook_data             = {}
+      hook_data["category"] = params["category"]
+      hook_data["event"]    = params["event"]
+      hook_data["data"]     = params["data"]
+
+      puts "Firing with: #{hook_data.inspect}"
+      event = "#{params['category']}.#{params['event']}".gsub('.', '_').to_sym
+
+      Cloudfuji::Data.fire(hook_data, event)
+
+      respond_to do |format|
+        format.json {render :json => {'acknowledged' => true}, :status => 200}
+      end
+    end
+  end
+end

data/app/controllers/cloudfuji/envs_controller.rb

@@ -0,0 +1,31 @@
+module Cloudfuji
+  class EnvsController < ApplicationController
+    # PUT /cloudfuji/envs/:id
+    def update
+      if ENV["CLOUDFUJI_APP_KEY"] != params[:key] or params[:id] == "CLOUDFUJI_KEY"
+        respond_to do |format|
+          format.html { render :layout => false, :text => true, :status => :forbidden }
+          format.json { render :status => :unprocessable_entity }
+        end
+
+      else
+
+        var = params[:id].upcase
+
+        ENV[var] = params[:value]
+        @value = ENV[var]
+        
+        respond_to do |format|
+          if @value != ENV[var]
+            format.html{render :layout => false, :text => true, :status => :unprocessable_entity}
+            format.json{render :status => :unprocessable_entity}
+          else
+            Cloudfuji::Data.fire(var, {var => ENV[var]})
+            format.html{render :text => true}
+            format.json{render :json => {var => ENV[var]}}
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/cloudfuji/mail_controller.rb

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+module Cloudfuji
+  class MailController < ApplicationController
+
+    # POST /cloudfuji/mail
+    def index
+      puts "Handling email!"
+      mail = {}
+      attachments = []
+
+      # Strip the attachments first
+      params.keys.each do |key|
+        attachments << params.delete(key) if key =~ /attachment-\d+/
+      end
+
+      # Copy the params to the hook data
+      (params.keys - ["controller", "action"]).each do |param|
+        mail[param.downcase] = params[param]
+      end
+
+      mail["attachments"] = attachments
+
+      puts "params: #{params.inspect}"
+      puts "mail: #{mail.inspect}"
+
+      # Output for debugging remotely
+      Cloudfuji::Mailroute.pretty_print_routes
+      puts "Finished routing"
+      
+      # Mailroute is in charge of figuring out which callback to trigger
+      Cloudfuji::Mailroute.routes.process(mail)
+
+      result = {:success => true, :message => nil, :data => {}}
+      render :text => result.to_json, :status => 200
+    end
+  end
+end

data/bin/cloudfuji

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+begin
+  require 'cloudfuji'
+rescue LoadError
+  $: << File.expand_path("../../lib", __FILE__)
+  require 'cloudfuji'
+end
+
+options = {}
+
+commands = [:login, :remove_account, :claim,  :list, :create, :show, :start, :stop, :restart, :update, :open, :logs, :add_var, :remove_var, :ssh_key, :api_key].sort_by {|s| s.to_s}
+
+help_docs = {
+  :login          => "cloudfuji login             - Authorizes this machine to work under your Cloudfuji account",
+  :api_key        => "cloudfuji api_key           - Prints out your Cloudfuji API key for use elsewhere (in the cloudfuji development webapp, for example)",
+  :remove_account => "cloudfuji remove_account    - Removes all Cloudfuji information from this machine",
+  :list           => "cloudfuji list              - List all of your deployed Cloudfuji apps",
+  :claim          => "cloudfuji claim      [NAME] - Claim a running Cloudfuji app as your own",
+  :create         => "cloudfuji create     [URL]  - Deploy a Cloudfuji app from a git repository in URL",
+  :show           => "cloudfuji show       [NAME] - Provide a detailed view of the Cloudfuji app",
+  :start          => "cloudfuji start      [NAME] - Turns the app on if it's been shut down for any reason",
+  :stop           => "cloudfuji stop       [NAME] - Turns the app off to prevent any access",
+  :restart        => "cloudfuji restart    [NAME] - Performace a stop and start in succession" ,
+  :update         => "cloudfuji update     [NAME] - Will stop the running cloudfuji app, pull from the url originally supplied to the app, update in place, and start back up",
+  :open           => "cloudfuji open       [NAME] - Open browser window to the running Cloudfuji app",
+  :create         => "cloudfuji create     [NAME] - Creates a new app",
+  :logs           => "cloudfuji logs       [NAME] - Retrieves all of the logs for an app and returns them in a JSON structure",
+  :ssh_key        => "cloudfuji ssh_key    [NAME] - Retrieves ssh_key for NAME, only needed for private repos (e.g. on github)",
+  :add_var        => "cloudfuji add_var    [NAME] [KEY] [VALUE] - Adds an environmental variable for an app to use",
+  :remove_var     => "cloudfuji remove_var [NAME] [KEY] - Removes an existing environmental variable from an app"
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: cloudfuji <command>"
+
+  opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+    options[:verbose] = v
+  end
+
+  opts.on("-h", "--help [command]", commands, "Help (this screen)") do |h|
+    if h.nil?
+      puts opts
+      puts "Supported commands: #{commands.join(', ')}"
+      exit
+    end
+
+    puts help_docs[h]
+    exit
+  end
+
+  opts.on_tail("-V", "--version", "Show version") do
+    puts Cloudfuji::VERSION.join('.')
+    exit
+  end
+end.parse!
+
+command = ARGV.first
+
+if command
+  case command.downcase.to_sym
+
+  when :claim           then Cloudfuji::App.claim(ARGV[1])
+  when :list            then Cloudfuji::App.list()
+  when :create          then Cloudfuji::App.create(ARGV[1])
+  when :show            then Cloudfuji::App.show(ARGV[1])
+  when :start           then Cloudfuji::App.start(ARGV[1])
+  when :stop            then Cloudfuji::App.stop(ARGV[1])
+  when :restart         then Cloudfuji::App.restart(ARGV[1])
+  when :update          then Cloudfuji::App.update(ARGV[1])
+  when :open            then Cloudfuji::App.open(ARGV[1])
+
+  when :add_domain      then Cloudfuji::App.add_domain(ARGV[1], ARGV[2])
+  when :remove_domain   then Cloudfuji::App.remove_domain(ARGV[1])
+  when :add_var         then Cloudfuji::App.add_var(ARGV[1], ARGV[2], ARGV[3])
+  when :remove_var      then Cloudfuji::App.remove_var(ARGV[1], ARGV[2])
+  when :clear_logs      then Cloudfuji::App.clear_logs(ARGV[1])
+  when :logs            then Cloudfuji::App.logs(ARGV[1])
+  when :ssh_key         then Cloudfuji::App.ssh_key(ARGV[1])
+  else
+    puts "I don't know how to '#{command}'"
+    puts "I do know how to do these though: #{commands.join(', ')}"
+  end
+else
+  puts "usage: cloudfuji <command>\n\nSee cloudfuji -h for more detailed instructions"
+  puts "Supported commands: #{commands.join(', ')}"
+end

data/cloudfuji.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cloudfuji/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cloudfuji"
+  s.version     = Cloudfuji::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Sean Grove", "Kev Zettler"]
+  s.email       = ["support@cloudfuji.com","s@cloudfuji.com"]
+  s.homepage    = "https://github.com/sgrove/cloudfujigem"
+  s.summary     = %q{Cloudfuji integration}
+  s.description = %q{A module for integrating the Cloudfuji platform into a rails app}
+
+  s.add_dependency "rest-client", ">=1.6.1"
+  s.add_dependency "json",        ">=1.4.6"
+  s.add_dependency "highline",    ">=1.6.1"
+  s.add_dependency "orm_adapter", "~> 0.0.3"
+
+  s.rubyforge_project = "cloudfuji"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,test_app,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/config/routes.rb

@@ -0,0 +1 @@
+

data/lib/cloudfuji.rb

@@ -0,0 +1,53 @@
+module Cloudfuji #:nodoc:
+  require 'optparse'
+  require 'rest_client'
+  require 'json'
+  require 'highline/import'
+  require 'orm_adapter'
+  require 'cloudfuji/engine'  
+  if defined?(Rails) && Rails::VERSION::MAJOR == 3
+    require "action_dispatch"
+  end
+  require "rails/routes"
+  require "cloudfuji/base"
+  require "cloudfuji/bar"
+  require "cloudfuji/config"
+  require "cloudfuji/smtp"
+  
+  require "hooks"
+  require "cloudfuji/platform"
+  require "cloudfuji/utils"
+  require "cloudfuji/command"
+  require "cloudfuji/app"
+  require "cloudfuji/user"
+  require "cloudfuji/event"
+  require "cloudfuji/version"
+  require "cloudfuji/envs"
+  require "cloudfuji/data"
+  require "cloudfuji/middleware"
+  require "cloudfuji/models"
+  require "cloudfuji/schema"
+  require "cloudfuji/event_observer"
+  require "cloudfuji/mail_route"
+  require "cloudfuji/user_helper"
+
+  # Manually require the controllers for rails 2
+  if defined?(Rails) && Rails::VERSION::MAJOR == 2
+    base_dir = "#{File.dirname(__FILE__)}/.."
+
+    require "#{base_dir}/app/controllers/cloudfuji/data_controller"
+    require "#{base_dir}/app/controllers/cloudfuji/mail_controller"
+    require "#{base_dir}/app/controllers/cloudfuji/envs_controller"
+    require "cloudfuji/action_mailer"
+  end
+
+  if defined?(Rails) && Rails::VERSION::MAJOR == 3
+    Cloudfuji::SMTP.setup_action_mailer_smtp!
+  end
+  
+  # Default way to setup Cloudfuji. Run rails generate cloudfuji_install to create
+  # a fresh initializer with all configuration values.
+  def self.setup
+    yield self
+  end
+end

data/lib/cloudfuji/action_mailer.rb

@@ -0,0 +1,35 @@
+module ActionMailer
+  class Base
+    private
+    def perform_delivery_cloudfuji(mail)
+      if mail.to.nil?
+        unless logger.nil?
+          logger.error "This mail isn't addressed to anyone! Dropping"
+        end
+
+        return false
+      end
+
+      #result = Cloudfuji::App.mail_allowed?
+      result = {"success" => true}
+
+      if result
+        logger.info result.inspect unless logger.nil?
+        if result["success"] == true
+          Cloudfuji::SMTP.setup_action_mailer_smtp!
+
+          unless logger.nil?
+            logger.info "App allowed to send email, sending via SMTP"
+            logger.info "Sending:"
+            logger.info mail.inspect
+            __send__("perform_delivery_smtp", mail) if perform_deliveries
+          end
+        else
+          logger.info "Unable to send email: #{result['message']}" unless logger.nil?
+        end
+      else
+        logger.info "Unable to contact Cloudfuji to verify email credentials" unless logger.nil?
+      end
+    end
+  end
+end

data/lib/cloudfuji/app.rb

@@ -0,0 +1,202 @@
+module Cloudfuji
+  # Cloudfuji::App provides all of the methods to interact with the app it's included in,
+  # and only contains class methods. Each method will check for the most recent data,
+  # so it's possible the data may change between two separate calls.
+  class App
+    class << self
+      def app_url #:nodoc:
+        "#{Cloudfuji::Platform.host}/apps/#{Cloudfuji::Platform.name}.json"
+      end
+
+
+      def get(params={}) #:nodoc:
+        Cloudfuji::Command.get_command(app_url, params)
+      end
+
+
+      def put(command, params={})  #:nodoc:
+        params[:command] = command
+
+        Cloudfuji::Command.put_command(app_url, params)
+      end
+
+
+      # Get all of the information related to the current app, returns a hash
+      def show
+        result = get
+      end
+
+
+      # Starts a currently stopped app
+      # ==== Example Scenario
+      # You may want to use this when recieving a \<tt>rake cloudfuji:message</tt> event to
+      # start up your app for an incoming message
+      def start
+        put :start
+      end
+
+
+      # Stops an app.
+      # ==== Example Scenario
+      # Use this if you want to put your application in 'maintenance mode'.
+      def stop
+        put :stop
+      end
+
+
+      # Stops (if started) and then starts an app
+      # ==== Example Scenario
+      # if you've added environmental variables to an application and need the app
+      # to restart to pick them up, use this.
+      def restart # :nodoc:
+        put :restart
+      end
+
+      # Claims an app for the current Cloudfuji user
+      # Raises an exception if app is launched anonymously
+      # ==== Example Scenario
+      # Integrate Cloudfuji app claiming behavior directly into your app to help
+      # conversion rates
+      def claim
+        put :claim
+      end
+
+
+      # Updates the app to the latest git checkout, using the branch the app
+      # was initially dpeloyed from
+      # ==== Example Scenario
+      # Allow your users to upgrade to the latest version via a link directly in your application
+      def update
+        put :update
+      end
+
+
+      # Add an environmental variable
+      # ==== Example Scenario
+      # Allows your app to easily integrate into third-party services, e.g. mixpanel.
+      # A user can enter their own API key, and you can activate your mixpanel code.
+      def add_var(key, value)
+        put :add_var, {:key => key, :value => value}
+        if Cloudfuji::Command.last_command_successful?
+          ENV[key.upcase] = value
+        end
+      end
+
+
+      # Remove an environmental variable
+      # ==== Example Scenario
+      # 
+      def remove_var(key)
+        put :remove_var, {:key => key}
+        if Cloudfuji::Command.last_command_successful?
+          ENV[key.upcase] = nil
+        end
+      end
+
+
+      # List all custom domains belonging to the current application
+      # ==== Example Scenario
+      # A CMS may want to use this if hosting multiple sites
+      def domains
+        get()["app"]["domains"]
+      end
+
+
+      # Returns the current subdomain of the app, whether that's the default
+      # (e.g. "happy-rabbit-12") or a custom-set subdomain ("my-example")
+      # ==== Example Scenario
+      # A CMS will use this to know which subdomain to respond to
+      def subdomain
+        get()["app"]["subdomain"]
+      end
+
+
+      # Check if a subdomain of cloudfuji.com is currently available
+      # ==== Example Scenario
+      # An application may want to change its subdomain to something user-chosen;
+      # use this before-hand to ensure it's available
+      def subdomain_available?(subdomain)
+        begin
+          return put :subdomain_available?, {:subdomain => subdomain}
+        rescue RestClient::UnprocessableEntity
+          return false
+        end
+      end
+
+
+      # Set the cloudfuji.com subdomain of an application
+      # ==== Example Scenario
+      # An app is initially launched to a randomly-generated subdomain, but may
+      # want to move to something more memorable for a given user.
+      def set_subdomain(subdomain)
+        result = put :set_subdomain!, {:subdomain => subdomain}
+        if Cloudfuji::Command.last_command_successful?
+          ENV["CLOUDFUJI_SUBDOMAIN"] = subdomain
+          ENV["PUBLIC_URL"] = "http://#{subdomain}.#{ENV['APP_TLD']}/"
+          return result
+        end
+
+        result
+      end
+
+
+      # Adds a domain to the Cloudfuji webrecords for an app. The app \<b>must</b>
+      # be a premium-app in order to add domains
+      # ==== Example Scenario
+      # If after launching a CMS a user decides to use a custom domain, an app
+      # can allow a user to customize it directly without resorting to the Cloudfuji
+      # app control panel.
+      def add_domain(domain)
+        put :add_domain!, {:domain => domain}
+      end
+
+
+      # Removes a custom domain from the Cloudfuji webrecords. Only works if the
+      # custom domain:
+      # * belongs to the current user
+      # * points at the current app
+      # ==== Example Scenario
+      # A user may decide to migrate a domain to a different app. This allows an app
+      # to remove it from its records without resorting to the Cloudfuji app
+      # control panel
+      def remove_domain(domain)
+        put :remove_domain!, {:domain => domain}
+      end
+
+
+      # Clear out the given log
+      # ==== Example Scenario
+      # An app may keep its production log for analysis by the end-user, but the
+      # user may want to clear out the irrelevant past logs.
+      def clear_log!(name)
+        put :clear_log!, {:name => name}
+      end
+
+
+      # Get all of the new logs. Returns a hash of the form {:name_of_log_X => "content of log X"}
+      # On Cloudfuji, there are by default the following logs:
+      # * access - Any page hit or asset request
+      # * error - Any error we had serving the page/asset
+      # * production - Output from the rails server
+      # * cloudfuji - logs from the cloudfuji deploy, update, start/stop process
+      #--
+      # TODO: Update to use the new logs controller
+      #++
+      def logs
+        get({:gift => "logs"})
+      end
+
+
+      # Check if the app is allowed to send emails
+      # Apps are rate-limited according to their tier
+      def mail_allowed?
+        Cloudfuji::Command.get_command(Cloudfuji::Base.allowed_email_url)
+      end
+
+
+      def ssh_key #:nodoc:
+        get({:gift => "ssh_key"})["ssh_key"]
+      end
+    end
+  end
+end