zena 1.0.0.beta2 → 1.0.0.beta3

data/lib/zena/deploy/awstats.conf.rhtml

@@ -48,7 +48,7 @@
 # If there is several log files from load balancing servers :
 # Example: "/pathtotools/logresolvemerge.pl *.log |"
 #
-LogFile="/var/www/zena/<%= host %>/log/apache2.access.log"
+LogFile="<%= config[:sites_root] %>/<%= config[:host] %>/log/apache2.access.log"
 
 
 # Enter the log file type you want to analyze.
@@ -150,7 +150,7 @@ LogSeparator=" "
 # Example: "ftp.domain.com"
 # Example: "domain.com"
 #
-SiteDomain="<%= host %>"
+SiteDomain="<%= config[:host] %>"
 
 
 # Enter here all other possible domain names, addresses or virtual host
@@ -165,7 +165,7 @@ SiteDomain="<%= host %>"
 # Note: You can also use @/mypath/myfile if list of aliases are in a file.
 # Example: "www.myserver.com localhost 127.0.0.1 REGEX[mydomain\.(net|org)$]"
 #
-HostAliases="localhost 127.0.0.1 <%= host %> stats.<%= host %>"
+HostAliases="localhost 127.0.0.1 <%= config[:host] %> stats.<%= config[:host] %>"
 
 
 # If you want to have hosts reported by name instead of ip address, AWStats
@@ -200,7 +200,7 @@ DNSLookup=2
 # Example: "C:/awstats_data_dir"
 # Default: "."          (means same directory as awstats.pl)
 #
-DirData="/var/www/zena/<%= host %>/log/awstats"
+DirData="<%= config[:sites_root] %>/<%= config[:host] %>/log/awstats"
 
 
 # Relative or absolute web URL of your awstats cgi-bin directory.

data/lib/zena/deploy/httpd.rhtml

@@ -3,7 +3,8 @@
 
 NameVirtualHost *
 <% if config[:app_type] == :passenger  %>
-LoadModule upload_progress_module <%= config[:app_root] %>/vendor/apache2_upload_progress/mod_upload_progress.so
+LoadModule upload_progress_module /usr/lib/apache2/modules/mod_upload_progress.so
+PassengerDefaultUser www-data
 <% elsif config[:app_type] == :mongrel %>
 <Proxy *>
   Order allow,deny

data/lib/zena/deploy/stats.vhost.rhtml

@@ -1,19 +1,19 @@
-# zena awstats vhost for <%= host %>
+# zena awstats vhost for <%= config[:host] %>
 # automatically generated file
 
 <VirtualHost *>
-  ServerName stats.<%= host %>
+  ServerName stats.<%= config[:host] %>
 
   DocumentRoot /usr/share/doc/awstats/examples
-  ErrorLog     /var/www/zena/<%= host %>/log/apache2.error.log
-  CustomLog    /var/www/zena/<%= host %>/log/apache2.access.log combined
+  ErrorLog     <%= config[:sites_root] %>/<%= config[:host] %>/log/apache2.error.log
+  CustomLog    <%= config[:sites_root] %>/<%= config[:host] %>/log/apache2.access.log combined
 
   <location />
-    SetEnv AWSTATS_FORCE_CONFIG <%= host %>
+    SetEnv AWSTATS_FORCE_CONFIG <%= config[:host] %>
 
     AuthType Basic
-    AuthName "<%= host %> stats"
-    AuthUserFile /var/www/zena/<%= host %>/log/.awstatspw
+    AuthName "<%= config[:host] %> stats"
+    AuthUserFile <%= config[:sites_root] %>/<%= config[:host] %>/log/.awstatspw
     Require valid-user
   </location>
 

data/lib/zena/deploy/vhost.rhtml

@@ -66,7 +66,7 @@
 	RewriteCond %{REQUEST_FILENAME} !-f
   RewriteRule ^/(.*)$ balancer://<%= config[:balancer] %>%{REQUEST_URI} [P,QSA,L]
 <% elsif config[:app_type] == :passenger %>
-  PassengerAppRoot <% config[:app_root] %>
+  PassengerAppRoot <%= config[:app_root] %>
 
   <Location />
     # enable tracking uploads in /

data/lib/zena/deploy/vhost_www.rhtml

@@ -1,10 +1,10 @@
-# zena apache2 vhost for <%= host %>
+# zena apache2 vhost for <%= config[:host] %>
 # automatically generated file
 
 <VirtualHost *>
-  ServerName www.<%= host %>
+  ServerName www.<%= config[:host] %>
 
   RewriteEngine On
-  RewriteCond %{HTTP_HOST} ^www\.<%= host %>$ [NC]
-  RewriteRule ^(.*)$ http://<%= host %>$1 [R=301,L]
+  RewriteCond %{HTTP_HOST} ^www\.<%= config[:host] %>$ [NC]
+  RewriteRule ^(.*)$ http://<%= config[:host] %>$1 [R=301,L]
 </VirtualHost>

data/lib/zena/foxy_parser.rb

@@ -80,10 +80,12 @@ module Zena
       @options  = opts
     end
 
+    def sites
+      @sites ||= Dir["#{Zena::ROOT}/test/sites/*", "#{RAILS_ROOT}/bricks/**/sites/*"].map {|s| File.directory?(s) ? File.basename(s) : nil}.compact.uniq
+    end
+
     def run
-      base = "#{Zena::ROOT}/test/sites"
-      Dir.foreach(base) do |site|
-        next if (site =~ /^\./) || !File.directory?(File.join(base, site))
+      sites.each do |site|
         @site = site
         parse_fixtures
         after_parse
@@ -834,8 +836,7 @@ module Zena
     end
 
     def run
-      Dir.foreach("#{Zena::ROOT}/test/sites") do |site|
-        next if site =~ /^\./ || !File.directory?(File.join("#{Zena::ROOT}/test/sites",site))
+      sites.each do |site|
         @inserted_keys = []
         out ""
         out "#{site}:"

data/lib/zena/info.rb

@@ -9,6 +9,6 @@ ZENA_CALENDAR_LANGS = ["en", "fr", "de"] # FIXME: build this dynamically from ex
 ENABLE_XSENDFILE = false
 
 module Zena
-  VERSION = '1.0.0.beta2'
+  VERSION = '1.0.0.beta3'
   ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
 end

data/lib/zena/integration/test_case.rb

@@ -10,7 +10,7 @@ module Zena
         Page.logger
       end
 
-      # Mock request to remote service by doing a call to the integration test.
+      # Mock ActiveResource request to remote service by doing a call to the integration test.
       def request(method, path, *arguments)
         case method
         when :get, :delete, :head
@@ -21,14 +21,19 @@ module Zena
           # The params here contain an xml string representing the request body.
           params  = arguments.first
         end
-        logger.info "#{method.to_s.upcase} #{site.scheme}://#{site.host}#{path} (#{arguments.last.inspect})" if logger
+        test_request(method, path, params, headers)
+      end
+
+      # Mock HTTParty::Request request
+      def test_request(method, path, params, headers, parse_response = true)
+        logger.info "#{method.to_s.upcase} #{site.scheme}://#{site.host}#{path} (#{headers.inspect})" if logger
         result = nil
         ms = Benchmark.ms do
           @test.send(method, "#{site.scheme}://#{site.host}#{path}", params, headers)
           result = @test.response
         end
         logger.info "--> %d %s (%d %.0fms)" % [result.code, result.message, result.body ? result.body.length : 0, ms] if logger
-        handle_response(result)
+        parse_response ? handle_response(result) : result
       rescue Timeout::Error => e
         raise TimeoutError.new(e.message)
       end

data/lib/zena/parser.rb

@@ -14,10 +14,10 @@ module Zena
         @strings = strings
       end
 
-      def get_template_text(src, current_dir)
-        current_dir = (current_dir && current_dir != '') ? current_dir[1..-1].split('/') : []
+      def get_template_text(src, base_path)
+        base_path = (base_path && base_path != '') ? base_path[1..-1].split('/') : []
         src = src[1..-1] if src[0..0] == '/' # just ignore the 'relative' or 'absolute' tricks.
-        url = (current_dir + src.split('/')).join('_')
+        url = (base_path + src.split('/')).join('_')
         if test = @strings[url]
           return [test['src'], url.split('_').join('/')]
         else
@@ -55,16 +55,16 @@ module Zena
         def new_with_url(url, opts={})
           helper = opts[:helper] || ParserModule::DummyHelper.new
           text, absolute_url = self.get_template_text(url, helper)
-          current_dir     = absolute_url ? absolute_url.split('/')[1..-2].join('/') : nil
-          self.new(text, :helper=>helper, :current_dir=>current_dir, :included_history=>[absolute_url], :root => url)
+          base_path     = absolute_url ? absolute_url.split('/')[1..-2].join('/') : nil
+          self.new(text, :helper=>helper, :base_path=>base_path, :included_history=>[absolute_url], :root => url)
         end
 
         # Retrieve the template text in the current folder or as an absolute path.
         # This method is used when 'including' text
-        def get_template_text(url, helper, current_dir=nil)
+        def get_template_text(url, helper, base_path=nil)
 
-          if (url[0..0] != '/') && current_dir
-            url = "#{current_dir}/#{url}"
+          if (url[0..0] != '/') && base_path
+            url = "#{base_path}/#{url}"
           end
 
           res = helper.send(:get_template_text, url, nil)
@@ -237,7 +237,7 @@ module Zena
         # fetch text
         @options[:included_history] ||= []
 
-        included_text, absolute_url = self.class.get_template_text(@params[:template], @options[:helper], @options[:current_dir])
+        included_text, absolute_url = self.class.get_template_text(@params[:template], @options[:helper], @options[:base_path])
 
         if included_text
           absolute_url += "::#{@params[:part].gsub('/','_')}" if @params[:part]
@@ -246,13 +246,13 @@ module Zena
             included_text = "<span class='parser_error'>[include] infinity loop: #{(@options[:included_history] + [absolute_url]).join(' --&gt; ')}</span>"
           else
             included_history  = @options[:included_history] + [absolute_url]
-            current_dir    = absolute_url.split('/')[1..-2].join('/')
+            base_path    = absolute_url.split('/')[1..-2].join('/')
           end
         else
           return "<span class='parser_error'>[include] template '#{url}' not found</span>"
         end
 
-        res = self.class.new(included_text, :helper=>@options[:helper], :current_dir=>current_dir, :included_history=>included_history, :part => @params[:part], :root=>@options[:root]) # we set :part to avoid loop failure when doing self inclusion
+        res = self.class.new(included_text, :helper=>@options[:helper], :base_path=>base_path, :included_history=>included_history, :part => @params[:part], :root=>@options[:root]) # we set :part to avoid loop failure when doing self inclusion
 
         if @params[:part]
           if iblock = res.ids[@params[:part]]

data/lib/zena/parser/zafu_tags.rb

@@ -125,7 +125,7 @@ module Zena
               $&
             else
               quote   = $1
-              new_src = @options[:helper].send(:template_url_for_asset, :current_dir=>@options[:current_dir], :src => $2)
+              new_src = @options[:helper].send(:template_url_for_asset, :base_path => @options[:base_path], :src => $2)
               "url(#{quote}#{new_src}#{quote})"
             end
           end
@@ -136,7 +136,7 @@ module Zena
 
         src = @params[key]
         if src && src[0..0] != '/' && src[0..6] != 'http://'
-          @params[key] = @options[:helper].send(:template_url_for_asset, :src => src, :current_dir => @options[:current_dir], :type => type)
+          @params[key] = @options[:helper].send(:template_url_for_asset, :src => src, :base_path => @options[:base_path], :type => type)
         end
 
         res   = "<#{@html_tag}#{params_to_html(@params)}"

data/lib/zena/remote.rb

@@ -0,0 +1,16 @@
+require 'active_support'
+require 'zena/remote/interface'
+require 'zena/remote/klass'
+require 'zena/remote/node'
+require 'zena/remote/connection'
+
+module Zena
+  module Remote
+    extend self
+
+    # Create a new connection to a remote Zena application
+    def connect(uri, token)
+      Connection.connect(uri, token)
+    end
+  end # Remote
+end # Zena

data/lib/zena/remote/connection.rb

@@ -0,0 +1,67 @@
+require 'HTTParty'
+
+module Zena
+  module Remote
+    class Connection
+      def initialize
+      end
+
+      # Return a sub-class of Zena::Remote::Connection with the specified connection tokens built in.
+      # We create a new class because HTTParty works this way (class globals).
+      def self.connect(uri, token)
+        Class.new(self) do
+          include HTTParty
+          extend Zena::Remote::Interface::ConnectionMethods
+
+          class << self
+            alias http_delete delete
+            alias delete destroy
+          end
+
+          @found_classes = {}
+          @uri = uri
+          @message_logger = STDOUT
+
+          def self.[](class_name)
+            @found_classes[class_name] ||= Zena::Remote::Klass.new(self, class_name)
+          end
+
+          def self.logger
+            @logger ||= default_logger
+          end
+
+          def self.log_message(msg)
+            logger = @message_logger || self.logger
+            if logger.respond_to?(:info)
+              logger.info "-\n"
+              logger.info "  %-10s: %s" % ['operation', 'message']
+              logger.info "  %-10s: %s" % ['message', msg.inspect]
+            else
+              @message_logger.send(:puts, msg)
+            end
+          end
+
+          def self.message_logger=(logger)
+            @message_logger = logger
+          end
+
+          def self.default_logger
+            host = URI.parse(@uri =~ %r{^\w+://} ? @uri : "http://#{@uri}").host
+            log_path = "log/#{host}.log"
+            dir = File.dirname(log_path)
+            Dir.mkdir(dir) unless File.exist?(dir)
+            Logger.new(File.open(log_path, 'ab'))
+          end
+
+          def self.logger=(logger)
+            @logger = logger
+          end
+
+          headers 'Accept' => 'application/xml'
+          headers 'HTTP_X_AUTHENTICATION_TOKEN' => token
+          base_uri uri
+        end
+      end
+    end
+  end # Remote
+end # Zena

data/lib/zena/remote/interface.rb

@@ -0,0 +1,405 @@
+module Zena
+  module Remote
+    module Interface
+
+      module Logger
+        def logger
+          @connection.logger
+        end
+
+        def log_message(msg)
+          @connection.log_message(msg)
+        end
+      end
+
+      # Methods to create new remote nodes.
+      module Create
+        # Used by @connection.create(...)
+        module ConnectionMethods
+          def create(attributes)
+            node = Zena::Remote::Node.new(self, attributes)
+            node.save
+            node
+          end
+        end
+
+        # Used by instance.save
+        module InstanceMethods
+          def post(*args)
+            @connection.post(*args)
+          end
+        end # InstanceMethods
+
+        # Used by connection['Post'].find(...)
+        module ClassMethods
+          def create(attributes)
+            node = new(attributes)
+            node.save
+            node
+          end
+
+          def new(attributes)
+            Zena::Remote::Node.new(@connection, attributes.stringify_keys.merge('class' => @name))
+          end
+        end # ClassMethods
+      end # Create
+
+      # Methods to retrieve remote nodes.
+      module Read
+        # Used by @connection.find(...)
+        module ConnectionMethods
+          def find_url
+            "/nodes/search"
+          end
+
+          def root
+            process_find(:first, 'root', {})
+          end
+        end
+
+        # Used by instance.find(...)
+        module InstanceMethods
+          def find_url
+            raise Exception.new("Cannot find from a new instance (no id).") unless id
+            "/nodes/#{id}/find"
+          end
+
+          def get(*args)
+            @connection.get(*args)
+          end
+        end
+
+        # Used by connection['Post'].find(...)
+        module ClassMethods
+          def find_url
+            "/nodes/search"
+          end
+
+          def get(*args)
+            @connection.get(*args)
+          end
+
+          def process_find(count, query, options = {})
+            if query.kind_of?(Hash)
+              query = query.symbolize_keys
+              klass = query.delete(:class) || @name
+
+              query_args = []
+
+              query.each do |key, value|
+                query_args << "#{key} = #{Zena::Db.quote(value)}"
+              end
+
+              query = "nodes where class like #{klass} and #{query_args.join(' and ')} in site"
+            elsif query.kind_of?(String)
+              # query must be a filter
+              query = "nodes where class like #{@name} and #{query} in site"
+            elsif query.kind_of?(Fixnum)
+              # query is an id
+              query = "nodes where class like #{@name} and id = #{query} in site"
+            else
+              # no filter
+              query = "nodes where class like #{@name} in site"
+            end
+
+            super(count, query, options)
+          end
+
+          def all(query = nil, options = {})
+            process_find(:all, query, options)
+          end
+
+          def first(query = nil, options = {})
+            process_find(:first, query, options)
+          end
+
+          def count(query = nil, options = {})
+            process_find(:count, query, options)
+          end
+        end # ClassMethods
+
+        # Find remote nodes with query builder or indexed search
+        def find(count, query = nil, options = {})
+          if query.nil?
+            query = count
+            count = count.kind_of?(Fixnum) ? :first : :all
+          end
+          process_find(count, query, options)
+        end
+
+        def search(query, options = {})
+          process_find(:all, {:q => query}, options)
+        end
+
+        def all(query, options = {})
+          process_find(:all, query, options)
+        end
+
+        def first(query, options = {})
+          process_find(:first, query, options)
+        end
+
+        def count(query, options = {})
+          process_find(:count, query, options)
+        end
+
+
+        private
+          def process_find(count, query, options)
+            if query.kind_of?(String)
+              # Consider string as pseudo sql
+              result = get(find_url, :query => options.merge(:qb => query, :_find => count))
+
+            elsif query.kind_of?(Fixnum)
+              # Find by id (== zip)
+              result = get("/nodes/#{query}")
+
+              if node = result['node']
+                result = {'nodes' => [node]}
+              end
+
+            else
+              # Find from indices title = ..., etc
+              result = get(find_url, :query => query.merge(options).merge(:_find => count))
+            end
+
+            if errors = result['errors']
+              errors.each do |error|
+                log_message error['message']
+              end
+            end
+
+            case count
+            when :first
+              if nodes = result['nodes']
+                if found_first = nodes.first
+                  return build_record(found_first)
+                else
+                  nil
+                end
+              else
+                nil
+              end
+            when :all
+              if nodes = result['nodes']
+                return nodes.map do |hash|
+                  build_record(hash)
+                end
+              else
+                []
+              end
+            when :count
+              if count = result['count']
+                return count
+              else
+                nil
+              end
+            else
+              raise Exception.new("Invalid count should be :all, :first or :count (found #{count.inspect})")
+            end
+          end
+
+          def build_record(hash)
+            Zena::Remote::Node.new(self, hash)
+          end
+      end # Read
+
+      # Methods to update a remote node.
+      module Update
+        # Used to mass update
+        module ConnectionMethods
+          def update(query, attributes)
+            if nodes = all(query)
+              # TODO: ask ?
+              logger.info "-\n"
+              logger.info "  %-10s: %s" % ['operation', 'mass update']
+              logger.info "  %-10s: %s" % ['timestamp', Time.now]
+              logger.info "  %-10s: %s" % ['query', query.inspect]
+              logger.info "  %-10s: %s" % ['count', nodes.size]
+              logger.info "  change:"
+              attributes.each do |key, value|
+                logger.info "    #{key}: #{value.inspect}"
+              end
+              nodes.each do |node|
+                if node.update_attributes(attributes)
+                else
+                  log_message "Could not update node #{node.id} (#{node.title}): #{node.errors.inspect}"
+                end
+              end
+              nodes
+            else
+              nil
+            end
+          end
+        end
+
+        # Used by instance.find(...)
+        module InstanceMethods
+          def update_url
+            node_url
+          end
+
+          def node_url
+            "/nodes/#{id}"
+          end
+
+          def create_url
+            "/nodes"
+          end
+
+          def put(*args)
+            @connection.put(*args)
+          end
+
+          def update_attributes(new_attributes)
+            saved_attributes = @attributes.dup
+            self.attributes = new_attributes
+            if save
+              logger.info "-\n"
+              logger.info "  %-10s: %s" % ['operation', 'update']
+              logger.info "  %-10s: %s" % ['timestamp', Time.now]
+              logger.info "  %-10s: %i" % ['node_id', id]
+              logger.info "  changes:"
+              @attributes.keys.each do |key|
+                next if saved_attributes[key] == @attributes[key]
+                logger.info "    #{key}:"
+                logger.info "      old: #{saved_attributes[key].inspect}"
+                logger.info "      new: #{@attributes[key].inspect}"
+              end
+            else
+              false
+            end
+          end
+
+          def save
+            if new_record?
+              result = post(create_url, :body => {:node => @attributes})
+            else
+              result = put(update_url, :body => {:node => @attributes})
+            end
+
+            if result.response.code =~ /^20\d$/
+              if node = result['node']
+                @attributes = node
+                node
+              elsif errors = result['errors']
+                @errors = errors
+                log_message errors
+                false
+              else
+                log_message "Could not save:"
+                log_message result.inspect
+                false
+              end
+            elsif errors = result['errors']
+              log_message "Could not save:"
+              log_message errors
+              false
+            else
+              log_message "Could not save:"
+              log_message result.inspect
+              false
+            end
+          end
+
+          def new_record?
+            id.nil?
+          end
+        end
+      end # Update
+
+      # Methods to delete a remote node.
+      module Delete
+        module ConnectionMethods
+          def destroy(query)
+            if nodes = all(query)
+              # TODO: ask ?
+              logger.info "-\n"
+              logger.info "  %-10s: %s" % ['operation', 'mass destroy']
+              logger.info "  %-10s: %s" % ['timestamp', Time.now]
+              logger.info "  %-10s: %s" % ['query', query.inspect]
+              logger.info "  %-10s: %s" % ['count', nodes.size]
+              nodes.each do |node|
+                if node.destroy
+                else
+                  log_message "Could not destroy node #{node.id} (#{node.title}): #{node.errors.inspect}"
+                end
+              end
+              nodes
+            else
+              nil
+            end
+          end
+        end # ConnectionMethods
+
+        module InstanceMethods
+          def destroy_url
+            node_url
+          end
+
+          def destroy
+            if id.nil?
+              @errors = ["cannot destroy inexistant remote node"]
+              return false
+            end
+            @previous_id = id
+            result = @connection.http_delete(destroy_url)
+            if result.code == 200
+              logger.info "  %-10s: %s" % ['operation', 'destroy']
+              logger.info "  %-10s: %s" % ['timestamp', Time.now]
+              logger.info "  %-10s: %s" % ['node_id', id]
+              logger.info "  attributes:"
+              @attributes.keys.each do |key|
+                logger.info "    #{key}: #{@attributes[key].inspect}"
+              end
+              true
+            elsif errors = result['errors']
+              @errors = errors
+              false
+            else
+              log_message "Could not destroy.. error:"
+              log_message result.inspect
+              false
+            end
+          end
+        end # InstanceMethods
+      end # Delete
+
+      # Extends the Connection class
+      module ConnectionMethods
+        include Create::ConnectionMethods
+
+        include Read
+        include Read::ConnectionMethods
+
+        include Update::ConnectionMethods
+
+        include Delete::ConnectionMethods
+      end
+
+      # Included in the Remote::Klass class
+      module ClassMethods
+        include Logger
+
+        include Create::ClassMethods
+
+        include Read
+        include Read::ClassMethods
+      end
+
+      # Included in the Remote::Node class
+      module InstanceMethods
+        include Logger
+
+        include Create::InstanceMethods
+
+        include Read
+        include Read::InstanceMethods
+
+        include Update::InstanceMethods
+
+        include Delete::InstanceMethods
+      end
+    end # Interface
+  end # Remote
+end # Zena