fanforce-plugin-factory 0.41.0 → 1.6.0.rc1

data/lib/fanforce/plugin_factory/cli/lib/bitbucket.rb

@@ -0,0 +1,77 @@
+require 'bitbucket_rest_api'
+require 'rest_client'
+require 'open3'
+
+class Fanforce::PluginFactory::CLI::Bitbucket
+  include Fanforce::PluginFactory::CLI::Utils
+
+  attr_reader :plugin
+
+  def initialize(plugin)
+    @plugin = plugin
+  end
+
+  def bitbucket
+    @@bitbucket = ::BitBucket.new(login: config[:bitbucket][:user], password: config[:bitbucket][:password])
+  end
+
+  def create
+    repo_name = "plugin-#{plugin.dir_name}"
+    error "Bitbucket repo already exists (#{repo_name})" if find_repo(repo_name)
+    create_repo(repo_name)
+    puts "#{'Created '.format(:green,:bold)}" + "#{repo_name} repository on bitbucket"
+  end
+
+  def setup
+    repo_name = "plugin-#{plugin.dir_name}"
+    error "Bitbucket repo does not exist (#{repo_name})" if !find_repo(repo_name)
+    "#{'Found   '.format(:green,:bold)}" + "#{repo_name} repository already exists on bitbucket"
+    setup_git_remote(repo_name)
+  end
+
+  def destroy
+    repo_name = "plugin-#{plugin.dir_name}"
+    if find_repo(repo_name)
+      RestClient::Request.execute(:method => :delete, :url => "https://#{config[:bitbucket][:user]}:#{config[:bitbucket][:password]}@api.bitbucket.org/1.0/repositories/#{config[:bitbucket][:user]}/#{repo_name}", :ssl_version => 'SSLv23')
+      puts "#{'Removed'.format(:green,:bold)}" + " #{repo_name}"
+    else
+      puts "#{'Already Removed'.format(:green,:bold)}" + " #{repo_name}"
+    end
+  end
+
+  def find_repo(repo_name)
+    bitbucket.repos.find(config[:bitbucket][:user], repo_name)
+  rescue
+    return nil
+  end
+
+  def setup_git_remote(repo_name)
+    Dir.chdir(plugin.dir) do
+      if console_command('git remote').split(/\r?\n/).include?('bitbucket')
+        log "#{'Found '.format(:green,:bold)}" + "git remote for bitbucket (#{config[:bitbucket][:user]})"
+      else
+        console_command("git remote add bitbucket git@bitbucket.org:#{config[:bitbucket][:user]}/#{repo_name}.git")
+        console_command('git fetch bitbucket')
+        log "#{'Created '.format(:green,:bold)}" + "git remote for bitbucket (#{config[:bitbucket][:user]})"
+      end
+
+      upstream_error = Open3.popen3('git rev-parse --abbrev-ref master@{upstream}')[2].gets.to_s
+      if upstream_error.include?('fatal')
+        console_command('git branch -u bitbucket/master')
+        log "#{'Connected '.format(:green,:bold)}" + 'upstream to bitbucket/master'
+      else
+        log "#{'Found '.format(:green,:bold)}" + 'upstream connection to bitbucket/master'
+      end
+
+      log "#{'Pushing '.format(:green,:bold)}" + 'latest commit to bitbucket/master...'
+      console_command('git push bitbucket --all', true)
+    end
+  end
+
+  def create_repo(repo_name)
+    bitbucket.repos.create(name: repo_name, is_private: true)
+  rescue ::BitBucket::Error::Unauthorized => e
+    raise "Bitbucket user #{config[:bitbucket][:user]} does not seem to exist: #{e.message}"
+  end
+
+end

data/lib/fanforce/plugin_factory/cli/lib/bundler.rb

@@ -0,0 +1,21 @@
+class Fanforce::PluginFactory::CLI::Bundler
+  include Fanforce::PluginFactory::CLI::Utils
+
+  attr_reader :plugin
+
+  def initialize(plugin)
+    @plugin = plugin
+  end
+
+  def setup
+    if Gem::Specification::find_all_by_name('bundler').empty?
+      puts 'Installing Bundler... '
+      `gem install bundler`
+      puts 'DONE'
+    end
+
+    console_command('bundle', true)
+    puts 'DONE'.format(:green)
+  end
+
+end

data/lib/fanforce/plugin_factory/cli/lib/env.rb

@@ -0,0 +1,96 @@
+require 'yaml'
+
+class Fanforce::PluginFactory::CLI::Env
+  include Fanforce::PluginFactory::CLI::Utils
+
+  attr_reader :plugin
+
+  def initialize(plugin)
+    @plugin = plugin
+  end
+
+  def setup(environment)
+    environment = environment.to_sym
+    bind_path = "#{plugin.dir}/../.env/_bind.yml"
+    error 'You must setup .env/_bind.yml before updating env variables.' if !File.exists?(bind_path)
+
+    vars = vars(environment)
+    has_workers = File.directory?("#{plugin.dir}/workers") ? true : false
+    return log "#{'Skipped'.format(:bold)} #{environment.to_s.titleize} has 0 env variables" if vars.blank? or vars.size == 0
+
+    push_to(environment, vars)
+    log "#{'Updated'.format(:green,:bold)} #{environment.to_s.titleize}#{has_workers ? '... and workers have' : ' has'} #{vars.size} env variables"
+  end
+
+  def push_to(environment, vars, create_worker_env=true)
+    environment = environment.to_sym
+    vars.each {|k,v| puts "  - #{k}" }
+    workers_dir = "#{plugin.dir}/workers"
+    workers_env_dir = "#{workers_dir}/.env"
+    if create_worker_env and File.directory?(workers_dir) and vars['IRON_PROJECT_ID']
+      FileUtils.mkdir_p(workers_env_dir) unless File.directory?(workers_env_dir)
+      File.open("#{workers_env_dir}/#{environment}.rb", 'w') {|f| f.write convert_hash_to_ruby_env(vars) }
+    end
+    if environment == :development
+      update_powenv
+      File.open("#{plugin.dir}/.pluginenv", 'w') {|f| f.write convert_hash_to_shell_env(vars) }
+    else
+      error 'could not find heroku in .fanforce-plugin-factory' if config[:heroku][environment].blank?
+      Fanforce::PluginFactory::CLI::Heroku.new(plugin).update_config(environment, vars)
+    end
+  end
+
+  def convert_hash_to_shell_env(hash)
+    hash.inject('') {|script, (k,v)| script += "export #{k}=#{v.to_s.to_json}\n" }
+  end
+
+  def convert_hash_to_ruby_env(hash)
+    hash.inject('') {|script, (k,v)| script += "ENV['#{k}']=#{v.to_s.to_json}\n" }
+  end
+
+  def load_vars(environment)
+    environment = environment.to_sym
+    vars = {'FANFORCE_PLUGIN_ID' => plugin._id}
+    raw_yaml = File.read("#{plugin.dir}/../.env/_bind.yml")
+    bindings = (raw_yaml.present?) ? YAML.load(raw_yaml) : {}
+    bindings.each do |filename, dir_names|
+      file = YAML.load_file("#{plugin.dir}/../.env/#{filename}.yml").symbolize_keys
+      next if file[environment].blank?
+
+      dir_names = [plugin.dir_name] if dir_names.is_a?(String) and dir_names.upcase == 'ALL'
+      file[environment].each do |k,v|
+        dir_names.each {|dir_name| vars["#{filename}_#{k}".upcase] = v if dir_name == plugin.dir_name }
+      end
+    end
+    return vars
+  end
+
+  def vars(environment)
+    @vars ||= {}
+    @vars[environment] ||= load_vars(environment)
+  end
+
+  # .POWENV #######################################################################
+
+  def create_powenv
+    file = powenv_lines.join("\n") + "\n"
+    File.open("#{plugin.dir}/.powenv", 'w') {|f| f.write file }
+  end
+
+  def update_powenv
+    return create_powenv if !File.exists?("#{plugin.dir}/.powenv")
+
+    lines = File.open("#{plugin.dir}/.powenv", 'r') {|f| f.readlines}.map {|l| l.strip }
+
+    powenv_lines.each do |line|
+      lines << line if !lines.include?(line)
+    end
+
+    File.open("#{plugin.dir}/.powenv", 'w') {|f| f.write(lines.join "\n") }
+  end
+
+  def powenv_lines
+    ['source .pluginenv']
+  end
+
+end

data/lib/fanforce/plugin_factory/cli/lib/git.rb

@@ -0,0 +1,59 @@
+class Fanforce::PluginFactory::CLI::Git
+  include Fanforce::PluginFactory::CLI::Utils
+
+  attr_reader :plugin
+
+  def initialize(plugin)
+    @plugin = plugin
+  end
+
+  def setup
+    if init.include?('Reinitialized')
+      puts "#{'Found '.format(:green,:bold)}" + 'existing local repository'
+    else
+      puts "#{'Initialized '.format(:green,:bold)}" + 'local repository'
+      add_files          and log '- git add .'
+      make_first_commit  and log '- git commit -m "initial fanforce commit"'
+      puts "#{'Created '.format(:green,:bold)}" + 'initial fanforce commit'
+    end
+  end
+
+  def self.status_table_header(plugin_column_width)
+    sprintf('%-12s %-50s %85s', 'GIT STATUS', 'PLUGIN NAME', 'STATS OVERVIEW').format(:bold)
+  end
+
+  def status_row(plugin_column_width)
+    sprintf("%s%-12s#{fmt_end} %-50s %28s %28s %28s",
+            fmt_start(is_committed ? :green : :red),
+            (is_committed ? 'Committed' : 'Uncommitted'),
+            plugin.name,
+            *changed_stats
+    )
+  end
+
+  def is_committed
+    `git status`.include?('nothing to commit') ? true : false
+  end
+
+  def changed_stats
+    stats_line = `git diff --stat`.split("\n").last
+    stats_line ? stats_line.split(', ') : Array.new(3)
+  end
+
+  private
+
+  def init
+    response = `git init`
+    `git config core.fileMode false`
+    return response
+  end
+
+  def add_files
+    `git add .`
+  end
+
+  def make_first_commit
+    `git commit -m "initial fanforce commit"`
+  end
+
+end

data/lib/fanforce/plugin_factory/cli/lib/heroku.rb

@@ -0,0 +1,94 @@
+class Fanforce::PluginFactory::CLI::Heroku
+  include Fanforce::PluginFactory::CLI::Utils
+
+  attr_reader :plugin
+
+  require_gem 'heroku-api', 'heroku-api'
+
+  def initialize(plugin)
+    @plugin = plugin
+  end
+
+  def heroku(environment)
+    @heroku ||= {}
+    @heroku[environment] ||= Heroku::API.new(:username => config[:heroku][environment][:user], :password => config[:heroku][environment][:password])
+  rescue Exception => e
+    error "OOPS...  #{environment.to_s.upcase}".format(:red,:bold) + ' has not been setup for Heroku' if config[:heroku].blank? or config[:heroku][environment].blank?
+    #raise "Heroku user #{config[:heroku][environment][:user]} does not seem to exist: #{e.message}" if e.response.status == 404
+    raise
+  end
+
+  def setup(environment)
+    environment = environment.to_sym
+    heroku = heroku(environment)
+    heroku_app_name = heroku_app_name_by_env(environment)
+
+    # Setup standard plugin domain
+    domain = "#{plugin._id}.#{Fanforce::Base::DomainEnvironments.method(environment).call[:plugins_base]}"
+    domain_found = heroku.get_domains(heroku_app_name).body.inject(false) {|result, d| d['domain'] == domain ? (break true) : false }
+    if domain_found
+      puts "#{'Found   '.format(:green,:bold)}" + "#{domain} domain on #{environment}"
+    else
+      heroku.post_domain(heroku_app_name, domain)
+      puts "#{'Added   '.format(:green,:bold)}" + "#{domain} domain to #{environment}"
+    end
+
+    # Setup default short domain
+    domain = "#{plugin._id}.#{Fanforce::Base::DomainEnvironments.method(environment).call[:default_short_domain]}"
+    domain_found = heroku.get_domains(heroku_app_name).body.inject(false) {|result, d| d['domain'] == domain ? (break true) : false }
+    if domain_found
+      puts "#{'Found   '.format(:green,:bold)}" + "#{domain} domain on #{environment}"
+    else
+      heroku.post_domain(heroku_app_name, domain)
+      puts "#{'Added   '.format(:green,:bold)}" + "#{domain} domain to #{environment}"
+    end
+
+    # Setup git remote
+    remote_name = "#{env(environment)}-heroku"
+    if (`git remote`).split(/\r?\n/).include?(remote_name)
+      puts "#{'Updated '.format(:green,:bold)}" + "git remote for #{remote_name}"
+      `git remote rm #{remote_name}`
+    else
+      puts "#{'Created '.format(:green,:bold)}" + "git remote for #{remote_name}"
+    end
+    `git remote add #{remote_name} git@#{config[:heroku][environment][:git_ssh_domain] || 'heroku.com'}:#{heroku_app_name}.git`
+  end
+
+  def heroku_app_exists?(heroku, heroku_app_name)
+    heroku.get_app(heroku_app_name)
+    return true
+  rescue
+    return false
+  end
+
+  def ensure_heroku_app_exists(environment)
+    heroku = heroku(environment)
+    heroku_app_name = heroku_app_name_by_env(environment)
+    if heroku_app_exists?(heroku, heroku_app_name)
+      puts "#{'Found   '.format(:green,:bold)}" + "#{environment} plugin on heroku (#{heroku_app_name})"
+    else
+      heroku.post_app(name: heroku_app_name)
+      puts "#{'Created '.format(:green,:bold)}" + "#{environment} on heroku (#{heroku_app_name})"
+    end
+  end
+
+  def update_config(environment, vars)
+    heroku(environment).put_config_vars(heroku_app_name_by_env(environment), vars) if vars
+  end
+
+  def env(environment)
+    case environment
+      when :staging then env = :stg
+      when :production then env = :prd
+    end
+  end
+
+  def heroku_app_name_by_env(environment)
+    environment = environment.to_sym
+    raise 'unknown environment' if ![:production, :staging].include?(environment)
+
+    heroku_app_name = "#{env(environment)}-#{plugin.dir_name}"
+    heroku_app_name.length > 30 ? heroku_app_name.gsub!(/(a|e|i|o|u)/, '') : heroku_app_name
+  end
+
+end

data/lib/fanforce/plugin_factory/cli/lib/iron.rb

@@ -0,0 +1,71 @@
+class Fanforce::PluginFactory::CLI::Iron
+  include Fanforce::PluginFactory::CLI::Utils
+
+  require_gem 'iron_worker_ng', 'iron_worker_ng'
+
+  attr_reader :plugin
+
+  def initialize(plugin)
+    @plugin = plugin
+  end
+
+  def upload(environment, worker_filename=nil)
+    if !File.directory?("#{plugin.dir}/workers")
+      return log "#{'Skipped '.format(:bold)} no workers folder was found"
+    end
+
+    env = Fanforce::PluginFactory::CLI::Env.new(plugin)
+    vars = env.vars(environment) || {}
+    factory_version = current_factory_version
+
+    return puts "#{'Skipped '.format(:bold)} #{environment.to_s.titleize} is missing IRON_TOKEN and/or IRON_PROJECT_ID env variables" if vars['IRON_TOKEN'].blank? or vars['IRON_PROJECT_ID'].blank?
+
+    puts "#{'Updating Env'.format(:green,:bold)} #{environment.to_s.titleize}... and workers have #{vars.size} env variables"
+    env.push_to(environment, vars, true)
+
+    iron_worker = IronWorkerNG::Client.new(:token => vars['IRON_TOKEN'], :project_id => vars['IRON_PROJECT_ID'])
+    Dir.chdir("#{plugin.dir}/workers") do
+      workers = Dir['*.worker']
+      return puts "#{'Skipped  '.format(:bold)} #{environment.to_s.titleize} has 0 workers" if workers.size == 0
+
+      upload_processes = []
+      FileUtils.cp("#{plugin.dir}/workers/.env/#{environment}.rb", "#{plugin.dir}/workers/.env/.#{environment}env.rb")
+      workers.each do |filename|
+        next if worker_filename and !filename.include?(worker_filename)
+        code_name = filename.gsub('.worker', '')
+
+        puts "#{'Uploading'.format(:green,:bold)} #{filename.gsub('.worker', '')} to #{environment.to_s.titleize}..."
+        code = IronWorkerNG::Code::Base.new(:workerfile => "#{plugin.dir}/workers/#{filename}")
+        code.gem('fanforce-plugin-factory', factory_version)
+        code.remote
+        code.name = code_name
+        code.file("#{plugin.dir}/workers/.env/.#{environment}env.rb")
+
+        upload_processes << upload_iron_worker(iron_worker, code, filename, environment)
+      end
+      upload_processes.each { |pid| Process.waitpid(pid) }
+      FileUtils.remove_file("#{plugin.dir}/workers/.env/.#{environment}env.rb")
+    end
+  end
+
+  def current_factory_version
+    `bundle list`.lines.each do |line|
+      return $1 if line =~ /fanforce-plugin-factory \(([A-Za-z0-9.-]+)\)/
+    end
+    error 'fanforce-plugin-factory version was not found in `bundle list`'
+  end
+
+  def upload_iron_worker(iron_worker, code, filename, environment)
+    fork do
+      begin
+        iron_worker.codes.create(code, max_concurrency: 5)
+      rescue Exception => e
+        puts "#{'Aborted  '.format(:red,:bold)} upload of #{filename.gsub('.worker', '')} to #{environment.to_s.titleize}..."
+        puts e.message
+        puts e.backtrace
+        puts ''
+      end
+    end
+  end
+
+end

data/lib/fanforce/plugin_factory/cli/lib/pow.rb

@@ -0,0 +1,46 @@
+class Fanforce::PluginFactory::CLI::Pow
+  include Fanforce::PluginFactory::CLI::Utils
+
+  attr_reader :plugin
+
+  def initialize(plugin)
+    @plugin = plugin
+  end
+
+  def setup
+    create_domain(plugin.root_domain)
+    create_domain(Fanforce.default_short_domain)
+  end
+
+  def destroy
+    destroy_domain(plugin.root_domain)
+    destroy_domain(Fanforce.default_short_domain)
+  end
+
+  def remove_domain_extension(domain)
+    domain.gsub(/\.[a-z]+$/, '')
+  end
+
+  def create_domain(root_domain)
+    domain = "#{plugin._id}.#{root_domain.gsub(/\.([a-z]+)$/, '')}"
+    domain_extension = $1
+    symlink = "#{ENV['HOME']}/.pow/#{domain}"
+
+    File.delete(symlink) if File.exists?(symlink) or File.symlink?(symlink)
+    `ln -s #{plugin.dir} #{symlink}`
+    puts "#{'Connected'.format(:bold,:green)} #{domain}.#{domain_extension} to #{plugin.dir}/"
+  end
+
+  def destroy_domain(root_domain)
+    domain = "#{plugin._id}.#{root_domain.gsub(/\.([a-z]+)$/, '')}"
+    domain_extension = $1
+    symlink = "#{ENV['HOME']}/.pow/#{domain}"
+    if File.exists?(symlink)
+      File.delete(symlink)
+      puts "#{'Removed'.format(:bold,:green)} #{domain}.#{domain_extension}"
+    else
+      puts "#{'Already Removed'.format(:bold,:green)} #{domain}.#{domain_extension} to #{plugin.dir}/"
+    end
+  end
+
+end