scout-camp 0.1.13 → 0.1.14

data/lib/scout/offsite/sync.rb

@@ -1,14 +1,39 @@
 require_relative 'ssh'
 class SSHLine
-  def self.locate(server, paths, map: :user)
-    SSHLine.scout server, <<-EOF
-map = :#{map}
-paths = [#{paths.collect{|p| "'" + p + "'" } * ", " }]
+
+  def self.locate(server, paths, map: :user, source: false)
+    paths = paths.collect do |path|
+      next path unless path.located?
+      relocated = Resource.identify(File.expand_path(path)).find_all.
+        select{|file| Open.same_file(file, path) }.
+        first
+      next path unless relocated
+      relocated.identify
+    end
+
+    script = <<-EOF
+map = #{map.nil? ? "nil" : ":#{map}" }
+paths = #{paths}
 located = paths.collect{|p| Path.setup(p).find(map) }
-identified = paths.collect{|p| Resource.identify(p) }
-located = located.collect{|path| path << "/" if path.directory? }
+    EOF
+
+    script += <<-EOF if source
+located = located.collect{|p| p.exists? ? p : nil }
+    EOF
+
+    script += <<-EOF
+identified = paths.collect{|p| Resource.identify(p) if p }
+located = located.each{|path| path << "/" if path && path.directory? && ! path.end_with?('/') }
 [located, identified]
     EOF
+
+    located, identified = SSHLine.scout server, script
+
+    identified.zip(paths).each do |ip,p|
+      ip.pkgdir = p.pkgdir if Path === p
+    end
+
+    [located, identified]
   end
 
   def self.rsync(source_path, target_path, directory: false, source: nil, target: nil, dry_run: false, hard_link: false)
@@ -24,11 +49,14 @@ located = located.collect{|path| path << "/" if path.directory? }
       Open.mkdir(File.dirname(target_path))
     end
 
+    source_path = File.expand_path(source_path) unless source
+    target_path = File.expand_path(target_path) unless target
+
     cmd = 'rsync '
     cmd << rsync_args
     cmd << '-nv ' if dry_run
-    cmd << (source ? [source, source_path] * ":" : source_path) << " "
-    cmd << (target ? [target, target_path] * ":" : target_path) << " "
+    cmd << (source ? [source, "'" + source_path + "'"] * ":" : "'" + source_path + "'") << " "
+    cmd << (target ? [target, "'" + target_path + "'"] * ":" : "'" + target_path + "'") << " "
 
     CMD.cmd_log(cmd, :log => Log::HIGH)
   end
@@ -38,14 +66,14 @@ located = located.collect{|path| path << "/" if path.directory? }
     target = nil if target == 'localhost'
 
     if source
-      source_paths, identified_paths = SSHLine.locate(source, paths)
+      source_paths, identified_paths = SSHLine.locate(source, paths, source: true)
     else
       source_paths = paths.collect{|p| Path === p ? p.find : p }
       identified_paths = paths.collect{|p| Resource.identify(p) }
     end
 
     if target
-      target_paths = SSHLine.locate(target, identified_paths, map: map)
+      target_paths, identified_paths = SSHLine.locate(target, identified_paths, map: map)
     else
       target_paths = identified_paths.collect{|p| p.find(map) }
     end

data/lib/scout/offsite.rb

@@ -1,3 +1,4 @@
 require_relative 'offsite/ssh'
 require_relative 'offsite/step'
 require_relative 'offsite/sync'
+require_relative 'offsite/resource'

data/lib/scout/render/engine.rb

@@ -0,0 +1,119 @@
+require_relative 'resource'
+require_relative 'helpers'
+
+require 'tilt'
+
+class TemplateNotFoundException < StandardError; end
+class FragmentNotFound < StandardError; end
+
+module ScoutRender
+  def self.render(template_file = nil, params = {}, &block)
+    exec_context = IndiferentHash.process_options params, 
+      :exec_context,
+      exec_context: self
+
+    if block && template_file.nil?
+      params = params.values if Hash === params
+      block.call *params
+    else
+      Log.debug "Render #{template_file}"
+      begin
+        Tilt.new(template_file).render(exec_context, params, &block)
+      ensure
+        exec_context.add_checks template_file if exec_context.respond_to?(:add_checks)
+      end
+    end
+  end
+
+  def self.render_step(template_file = nil, options = {}, &block)
+    exec_context = IndiferentHash.process_options options, :exec_context
+
+    persist_options = IndiferentHash.pull_keys options, :persist
+
+    persist_options = IndiferentHash.add_defaults persist_options, 
+      dir: ScoutRender.cache_dir, 
+      other: options, 
+      name: "Step"
+
+    step_name = IndiferentHash.process_options persist_options, :step
+
+    if step_name
+      dir = persist_options[:dir]
+      path = Path === dir ? dir[step_name] : File.join(dir, step_name)
+      persist_options[:path] = path
+    end
+    
+    path, extension, update = IndiferentHash.process_options persist_options, 
+      :path, :extension, :update,
+      path: Persist.persistence_path(persist_options[:name], persist_options),
+      extension: 'html',
+      update: update
+
+    path = path.set_extension extension if extension and ! path.end_with?(".#{extension}")
+
+    if block
+      step = Step.new path, options, exec_context: exec_context, &block
+    else
+      step = Step.new path, options, exec_context: exec_context do
+        ScoutRender.render(template_file, options.merge(exec_context: self))
+      end
+    end
+
+    step.exec_context = step unless exec_context
+    
+    step.type = :text
+
+    step.extend ScoutRenderHelpers if exec_context.nil?
+
+    step.exec_context.instance_variable_set(:@step, step)
+
+    step
+  end
+
+  def self.render_template(template = nil, options = {}, &block)
+    options = IndiferentHash.add_defaults options, persist_name: template
+
+    extension, update, run, cache, check = IndiferentHash.process_options options, 
+      :extension, :update, :run, :cache, :check,
+      extension: %w(slim haml erb),
+      run: true,
+      cache: true
+
+    template_file = ScoutRender.find_resource(template, extension: extension) if template
+
+    raise TemplateNotFoundException, template unless template_file.nil? || template_file.exists?
+
+    return ScoutRender.render(template_file, options, &block) if ! cache
+
+    step = ScoutRender.render_step(template_file, options, &block)
+
+    #checks = step.info[:checks] || []
+    #checks << check if check
+    #checks << [template_file]
+    #checks = checks.flatten.uniq
+    #step.set_info :checks, checks
+
+    case update
+    when :false, 'false', false, :wait, 'wait'
+    when :true, 'true', true, :reload, 'reload'
+      step.clean
+    when nil
+      if checks = step.info[:checks]
+        step.clean if (step.done? || step.error?) && step.path.outdated?(checks)
+      end
+    else
+      step.clean if step.error? && step.recoverable_error?
+      step.clean unless step.running?
+    end
+
+    if run
+      step.run unless step.done?
+    else
+      step
+    end
+  end
+
+  def self.render_partial(template, options = {})
+    render_template(template, options)
+  end
+end

data/lib/scout/render/helpers.rb

@@ -0,0 +1,92 @@
+module ScoutRenderHelpers
+  def escape_html(text)
+    Rack::Utils.escape_html(text)
+  end
+
+  def hash_to_html_tag_attributes(hash)
+    return "" if hash.nil? or hash.empty?
+    hash.collect{|k,v| 
+      case 
+      when (k.nil? or v.nil? or (String === v and v.empty?))
+        nil
+      when Array === v
+        [k,"'" << v * " " << "'"] * "="
+      when String === v
+        [k,"'" << v << "'"] * "="
+      when Symbol === v
+        [k,"'" << v.to_s << "'"] * "="
+      when TrueClass === v
+        [k,"'" << v.to_s << "'"] * "="
+      when Numeric === v
+        [k,"'" << v.to_s << "'"] * "="
+      else
+        nil
+      end
+    }.compact * " "
+  end
+
+  def html_tag(tag, content = nil, params = {})
+    attr_str = hash_to_html_tag_attributes(params)
+    attr_str = " " << attr_str if String === attr_str and attr_str != ""
+    html = if content.nil?
+      "<#{ tag }#{attr_str}/>"
+    else
+      "<#{ tag }#{attr_str}>#{ content.to_s }</#{ tag }>"
+    end
+
+    html
+  end
+
+  def remove_GET_param(url, param)
+    if Array === param
+      param.each do |p|
+        url = remove_GET_param(url, p)
+      end
+    else
+      url = url.gsub(/(\?|&)#{param}=[^&]+/,'\1')
+    end
+
+    url = url.sub(/\?&/, '?')
+    url = url.sub(/&&*/, '&')
+    url = url.sub(/&$/, '')
+    url = url.sub(/\?$/,'')
+    url
+  end
+
+  def add_GET_param(url, param, value)
+    url = remove_GET_param(url, param)
+    if url =~ /\?.+=/
+      url + "&#{ param }=#{ value }"
+    else
+      url + "?#{ param }=#{ value }"
+    end
+  end
+
+  def add_GET_params(url, params)
+    params.each do |k,v|
+      url = add_GET_param(url, k, v)
+    end
+    url
+  end
+
+  def add_checks(checks)
+    return unless Step === @step
+    checks = [checks] unless Array === checks
+    current_checks = @step.info[:checks] || []
+
+    new_files = checks - current_checks
+    @step.set_info :checks, new_files if new_files.any?
+  end
+
+  def outdated?
+    return false unless Step === @step
+    return false unless @step.path.exists?
+    current_checks = @step.info[:checks] || []
+    @step.path.outdated?(current_checks)
+  end
+
+  def log(...)
+    return unless Step === @step
+    @step.log(...)
+  end
+end

data/lib/scout/render/resource.rb

@@ -0,0 +1,54 @@
+require 'scout'
+module ScoutRender
+  extend Resource
+
+  self.subdir = 'share/views'
+
+  def self.find_resource(name, extension: %w(slim erb haml)  )
+    return name.find_with_extension(extension) if Path === name && name.find_with_extension(extension).exists?
+    ScoutRender.root[name].find_with_extension(extension)
+  end
+
+  def self.exists?(name, extension: %w(slim erb haml)  )
+    find_resource(name, extension: extension).exists?
+  end
+
+  def self.find_haml(name)
+    find_resource(name, extension: 'haml')
+  end
+
+  def self.find_slim(name)
+    find_resource(name, extension: 'slim')
+  end
+
+  def self.find_js(name)
+    find_resource(name, extension: 'js')
+  end
+
+  def self.find_css(name)
+    find_resource(name, extension: 'css')
+  end
+
+
+  def self.find_sass(name)
+    find_resource(name, extension: 'sass')
+  end
+
+  class << self
+    undef :method_missing
+
+    attr_accessor :app_dir, :cache_dir, :files_dir
+
+    def app_dir
+      @app_dir ||= Scout.var.render[self.to_s]
+    end
+
+    def cache_dir
+      @cache_dir ||= app_dir.cache
+    end
+
+    def files_dir
+      @files_dir ||= app_dir.files
+    end
+  end
+end

data/lib/scout/render.rb

@@ -0,0 +1,3 @@
+require_relative 'render/resource'
+require_relative 'render/helpers'
+require_relative 'render/engine'

data/lib/scout/sinatra/auth.rb

@@ -0,0 +1,158 @@
+require "sinatra"
+require "omniauth"
+require "omniauth-google-oauth2"
+
+module SinatraScoutAuth
+  def self.registered(app)
+
+    app.use OmniAuth::Builder do
+      client_id = Scout::Config.get :client, :google, :google_oauth, env:"GOOGLE_CLIENT_ID"
+      client_secret = Scout::Config.get :secret, :google, :google_oauth, env:"GOOGLE_CLIENT_SECRET"
+      provider :google_oauth2, client_id, client_secret,
+        access_type: 'offline',
+        prompt: 'select_account',
+        scope: 'email',
+        setup: lambda { |env|
+          script_name = env['HTTP_SCRIPT_NAME']
+          if script_name
+            referer = env['rack.session']['return_to']
+			uri = URI.parse(referer)
+			# Keep only scheme + host + (optional port)
+			base = "#{uri.scheme}://#{uri.host}"
+			base += ":#{uri.port}" if uri.port && ![80, 443].include?(uri.port)
+
+			# Construct full redirect URI
+			redirect_uri = "#{base}#{script_name}/auth/google_oauth2/callback"
+
+            strategy = env['omniauth.strategy']
+
+            strategy.options[:redirect_uri] = redirect_uri
+          end
+
+          puts "OmniAuth session: #{env['rack.session'].inspect}"
+        }
+    end
+
+    app.before do
+      load_preferences
+    end
+
+    app.get "/auth/login" do
+      session[:return_to] = to(request.referer || "/")
+
+      render_or 'auth/login', <<~HTML
+          <form method='get' action='/auth/google_oauth2'>
+          <input type="hidden" name="authenticity_token" value='#{request.env["rack.session"]["csrf"]}'>
+          <button type='submit'>Login with Google</button>
+          </form>
+      HTML
+    end
+
+    app.get "/auth/:provider/callback" do
+      auth = request.env["omniauth.auth"]
+
+      # Store relevant info in session
+      session[:user] = {
+        uid: auth.uid,
+        name: auth.info.name,
+        email: auth.info.email,
+        image: auth.info.image
+      }
+
+      return_to = session[:return_to]
+      redirect return_to || "/"
+    end
+
+    app.get "/auth/logout" do
+      return_to = session[:return_to]
+      session.clear
+      render_or 'auth/logout', nil, return_to: return_to do
+        redirect return_to || "/"
+      end
+    end
+
+    app.get "/auth/failure" do
+      render_or 'auth/fail', "Authentication failed: #{params[:message]}"
+    end
+
+    app.helpers do
+      def current_user
+        session[:user]
+      end
+
+      def authenticated?
+        !current_user.nil?
+      end
+
+      def protected!
+        render_or 'auth/missing', "Not authorized" unless authenticated?
+      end
+
+      def user_name
+        case current_user
+        when Hash
+          current_user[:name] || current_user['name'] || current_user[:email] || current_user['email']
+        when String
+          current_user
+        end
+      end
+
+      def user_dir
+        Scout.var.sinatra.users[user_name]
+      end
+
+      def user_file(file)
+        user_dir[file.to_s]
+      end
+
+      def user_save(file, content)
+        Open.sensible_write(user_file(file), content, force: true)
+      end
+
+      def user_load(file)
+        return nil unless user_file(file).exists?
+        user_file(file).read
+      end
+
+      def save_preferences
+        Log.debug "save #{preferences.to_json}"
+        user_save(:preferences, preferences.to_json)
+      end
+
+      def load_preferences
+        return unless user_file(:preferences).exists?
+        session['preferences'] = JSON.parse(user_load(:preferences))
+        session['preferences_time'] = Open.mtime(user_file(:preferences))
+      end
+
+      def updated_preferrences?
+        return true if session['preferences_time'].nil?
+        session['preferences_time'] < Open.mtime(user_file(:preferences))
+      end
+
+      def preferences_changed
+        @preferences_changed ||= []
+      end
+
+      def record_preference(key, value)
+        preferences_changed << key
+        preferences[key] = value
+        save_preferences if current_user
+        value
+      end
+
+      def get_preference(key)
+        load_preferences if current_user && updated_preferrences?
+        preferences[key]
+      end
+
+      def preference(key, default= nil, &block)
+        current = get_preference(key)
+        return current unless current.nil?
+        default = block.call if default.nil? and block_given?
+        record_preference(key, default) if default
+        default
+      end
+    end
+  end
+end