read_from_slave 0.4.0 → 0.5.0

data/README

@@ -1,9 +1,11 @@
 Read_from_slave
 
-Read_from_slave for Rails enables database reads from a slave database, while writes continue to go to the master
+Read_from_slave for Rails enables database reads from one or more slave databases, while writes continue to go to the master
 
 Read_from_slave will work with Rails 2.2 and above, including Rails 3 versions.
 
+Note that this version (0.5.x) supports multiple slave databases, but this caused an incompatibility in the configuration - your database.yml file must be updated before you can use this version.
+
 Installation
 
 gem install read_from_slave
@@ -16,24 +18,82 @@ In config/environments/production.rb (for instance)
 
 In config/database.yml
 
-  production:
-    adapter: mysql
-    database: mydatabase
-    username: myuser
-    password: mypassword
-    host: my.main.database.server.com
-    port: 3306
-
-  slave_for_mydatabase:
-    adapter: mysql
-    database: mydatabase
-    username: myuser
-    password: mypassword
-    socket: /var/lib/mysql/mysql.sock
+   production:
+     adapter: mysql
+     database: mydatabase
+     username: myuser
+     password: mypassword
+     host: my.main.database.server.com
+     port: 3306
+     slaves:
+       primary_slave:  slave_for_reads
+       slave_2:  slave_for_reporting
+
+   slave_for_reads:
+     adapter: mysql
+     database: mydatabase
+     username: myuser
+     password: mypassword
+     socket: /var/lib/mysql/mysql.sock
+
+   slave_for_reporting:
+     adapter: mysql
+     database: mydatabase
+     username: myuser
+     password: mypassword
+     host: my.slave.database.server.com
 
 Just use the regular YAML format to specify your slave database, it could equally well be on
 another server as the local example given above.
 
+In the example above, primary_slave and slave_2 are names that are used to generate methods you can use to specify which slave to use.
+slave_for_reads and slave_for_reporting is the yaml key that is used to make the connection to your slave database.
+
+You can have any number of slaves configured.  To connect to the slaves:
+
+ActiveRecord::Base.with_primary_slave do
+    User.last
+end
+
+ActiveRecord::Base.with_slave_2 do
+    User.last
+end
+
+with_primary_slave and with_slave_2 are dynamically created based on the keys provided in the yaml file.  Everything
+inside the block with read from the corresponding slave database specified in the yaml file.
+
+You must have one slave with the primary_slave key.  By default, all the reads will occur on the primary_slave,
+in the example above, and not require you to use the with_primary_slave method.  You actually never need to use
+the with_primary_slave method as that slave will alwaysbe used if not inside a with... method block.  So if you only have
+1 slave, you don't ever need to worry about the with... methods.
+
+If you have multiple slaves, you will want to make sure you specify slave configurations for each environment, even if you
+don't have slaves in every environment.
+
+development:
+     adapter: mysql
+     database: mydatabase
+     username: myuser
+     password: mypassword
+     host: my.main.database.server.com
+     port: 3306
+     slaves:
+       primary_slave:  development
+       slave_2:  development
+
+The reason is, your code will have with_primary_slave and with_slave_2 methods because that is what you need in production,
+but you will get undefined method errors in development because they won't be generated unless your development configuration
+specifies slaves.  Just specifying the slave keys back to the development configuration should serve your needs.
+
+You may have a need where you don't actually want all of your reads to be on the slave.  You may want to be much more
+selective in what you put on the slave.  For instance, perhaps you want everything on the master except large reports.
+You can change the default behavior of read_from_slave by setting:
+
+ReadFromSlave.all_reads_on_slave = false
+
+in your environment.rb file.  This will make all reads on the master by default and reads will only be on the slave inside
+the with... method blocks.
+
 Phusion Passenger
 
 Note that if you are using Passenger, you need to make sure that the slave database is reconnected
@@ -45,10 +105,10 @@ The safest thing to do is to have something like this in your production.rb or e
 
   PhusionPassenger.on_event(:starting_worker_process) do |forked|
     if forked
-      # We're in smart spawning mode.                                                               
+      # We're in smart spawning mode.
       ActiveRecord::Base.establish_slave_connections
     else
-      # We're in conservative spawning mode. We don't need to do anything.                          
+      # We're in conservative spawning mode. We don't need to do anything.
     end
   end
 
@@ -63,18 +123,14 @@ Clone the git repository, and you can run the read_from_slave tests or entire Ac
   $ rake test
   ...snip..
   Finished in 0.046365 seconds.
-  
+
   7 tests, 7 assertions, 0 failures, 0 errors
-  
+
   $ rake test_with_active_record
   ...snip...
   Finished in 51.904306 seconds.
-  
-  2057 tests, 6685 assertions, 0 failures, 0 errors
 
-Todo
-
-* Support a pool of multiple slaves
+  2057 tests, 6685 assertions, 0 failures, 0 errors
 
 References
 
@@ -93,4 +149,5 @@ another one, proxy connection approach
 looks like it won't work with apps that talk to multiple (master) databases
 more complex than read_from_slave
 
-(c) 2009 Stephen Sykes
+(c) 2009-2011 Stephen Sykes
+Thanks to Kevin Tyll for contributing the multiple slave feature

data/README.textile

@@ -1,9 +1,11 @@
 h1. Read_from_slave
 
-h4. Read_from_slave for Rails enables database reads from a slave database, while writes continue to go to the master
+h4. Read_from_slave for Rails enables database reads from one or more slave databases, while writes continue to go to the master
 
 Read_from_slave will work with Rails 2.2 and above, including Rails 3 versions.
 
+Note that this version (0.5.x) supports multiple slave databases, but this caused an incompatibility in the configuration - your database.yml file must be updated before you can use this version.
+
 h2. Installation
 
 <pre>
@@ -26,26 +28,96 @@ In config/database.yml
 
 <pre>
 <code>
-production:
-  adapter: mysql
-  database: mydatabase
-  username: myuser
-  password: mypassword
-  host: my.main.database.server.com
-  port: 3306
-
-slave_for_mydatabase:
-  adapter: mysql
-  database: mydatabase
-  username: myuser
-  password: mypassword
-  socket: /var/lib/mysql/mysql.sock
+   production:
+     adapter: mysql
+     database: mydatabase
+     username: myuser
+     password: mypassword
+     host: my.main.database.server.com
+     port: 3306
+     slaves:
+       primary_slave:  slave_for_reads
+       slave_2:  slave_for_reporting
+
+   slave_for_reads:
+     adapter: mysql
+     database: mydatabase
+     username: myuser
+     password: mypassword
+     socket: /var/lib/mysql/mysql.sock
+
+   slave_for_reporting:
+     adapter: mysql
+     database: mydatabase
+     username: myuser
+     password: mypassword
+     host: my.slave.database.server.com
 </code>
 </pre>
 
 Just use the regular YAML format to specify your slave database, it could equally well be on
 another server as the local example given above.
 
+In the example above, primary_slave and slave_2 are names that are used to generate methods you can use to specify which slave to use.
+slave_for_reads and slave_for_reporting is the yaml key that is used to make the connection to your slave database.
+
+You can have any number of slaves configured.  To connect to the slaves:
+
+<pre>
+<code>
+ActiveRecord::Base.with_primary_slave do
+    User.last
+end
+
+ActiveRecord::Base.with_slave_2 do
+    User.last
+end
+</pre>
+</code>
+
+with_primary_slave and with_slave_2 are dynamically created based on the keys provided in the yaml file.  Everything
+inside the block with read from the corresponding slave database specified in the yaml file.
+
+You must have one slave with the primary_slave key.  By default, all the reads will occur on the primary_slave,
+in the example above, and not require you to use the with_primary_slave method.  You actually never need to use
+the with_primary_slave method as that slave will alwaysbe used if not inside a with... method block.  So if you only have
+1 slave, you don't ever need to worry about the with... methods.
+
+If you have multiple slaves, you will want to make sure you specify slave configurations for each environment, even if you
+don't have slaves in every environment.
+
+<pre>
+<code>
+development:
+     adapter: mysql
+     database: mydatabase
+     username: myuser
+     password: mypassword
+     host: my.main.database.server.com
+     port: 3306
+     slaves:
+       primary_slave:  development
+       slave_2:  development
+</pre>
+</code>
+
+The reason is, your code will have with_primary_slave and with_slave_2 methods because that is what you need in production,
+but you will get undefined method errors in development because they won't be generated unless your development configuration
+specifies slaves.  Just specifying the slave keys back to the development configuration should serve your needs.
+
+You may have a need where you don't actually want all of your reads to be on the slave.  You may want to be much more
+selective in what you put on the slave.  For instance, perhaps you want everything on the master except large reports.
+You can change the default behavior of read_from_slave by setting:
+
+<pre>
+<code>
+ReadFromSlave.all_reads_on_slave = false
+</pre>
+</code>
+
+in your environment.rb file.  This will make all reads on the master by default and reads will only be on the slave inside
+the with... method blocks.
+
 h2. Phusion Passenger
 
 Note that if you are using Passenger, you need to make sure that the slave database is reconnected
@@ -92,10 +164,6 @@ Finished in 51.904306 seconds.
 </code>
 </pre>
 
-h2. Todo
-
-* Support a pool of multiple slaves
-
 h2. References
 
 * "Masochism":http://github.com/technoweenie/masochism/tree/master
@@ -112,3 +180,4 @@ h2. References
 
 
 (c) 2009 Stephen Sykes
+Thanks to Kevin Tyll for contributing the multiple slave feature

data/Rakefile

@@ -19,20 +19,3 @@ Rake::TestTask.new(:test_read_from_slave) do |t|
   t.test_files = ReadFromSlave::Test.test_files
   t.verbose = true
 end
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |s|
-    s.name = "read_from_slave"
-    s.summary = "Read_from_slave - Utilise your slave databases with rails"
-    s.email = "sdsykes@gmail.com"
-    s.homepage = "http://github.com/sdsykes/read_from_slave"
-    s.description = "Read_from_slave for Rails enables database reads from a slave database, while writes continue to go to the master"
-    s.authors = ["Stephen Sykes"]
-    s.files = FileList["[A-Z]*", "{lib,test}/**/*"]
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://
-gems.github.com"
-end

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
-:minor: 4
+:minor: 5
 :build: 
 :major: 0
 :patch: 0

data/lib/read_from_slave.rb

@@ -1,4 +1,4 @@
-# Read_from_slave for Rails enables database reads from a slave database, while writes continue 
+# Read_from_slave for Rails enables database reads from one or more slave databases, while writes continue
 # to go to the master
 # To use read_from_slave you must install the gem, configure the gem in your environment file,
 # and setup your database.yml file with an entry for your slave database.
@@ -12,7 +12,7 @@
 #
 #   config.gem "read_from_slave"
 #
-# In config/database.yml  
+# In config/database.yml
 #
 #   production:
 #     adapter: mysql
@@ -21,16 +21,25 @@
 #     password: mypassword
 #     host: my.main.database.server.com
 #     port: 3306
+#     slaves:
+#       slave_1:  slave_for_reads
+#       slave_2:  slave_for_reporting
 #
-#   slave_for_mydatabase:
+#   slave_for_reads:
 #     adapter: mysql
 #     database: mydatabase
 #     username: myuser
 #     password: mypassword
 #     socket: /var/lib/mysql/mysql.sock
 #
-# Note that if you have multiple databases you can also configure multiple slaves - use the
-# database name after slave_for_ in the configuration.
+#   slave_for_reporting:
+#     adapter: mysql
+#     database: mydatabase
+#     username: myuser
+#     password: mypassword
+#     host: my.slave.database.server.com
+#
+# Note that if you have multiple databases you can also configure multiple slaves.
 #
 # === References
 # * "Masochism":http://github.com/technoweenie/masochism/tree/master
@@ -58,7 +67,7 @@ module ReadFromSlave
           alias_method_chain :connection, :read_from_slave
         end
       end
-      
+
       begin
         calculation_base = ActiveRecord::Relation  # rails 3
         calculation_base.send(:include, CalculationMethod)
@@ -72,6 +81,26 @@ module ReadFromSlave
         end
       end
     end
+
+    def default_to_master!
+      base = ActiveRecord::Base
+      base.class_eval do
+        class << self
+          alias_method_chain :connection, :slave_db_scope unless ReadFromSlave.all_reads_on_slave
+        end
+      end
+    end
+
+    @@all_reads_on_slave = true
+    def all_reads_on_slave=(all_reads)
+      @@all_reads_on_slave = all_reads
+      default_to_master!
+    end
+
+    def all_reads_on_slave
+      @@all_reads_on_slave
+    end
+
   end
 
   module InstanceMethods
@@ -92,84 +121,127 @@ module ReadFromSlave
       Thread.current[:read_from_slave] = false
     end
 
+    ActiveRecord::Base.connection.instance_variable_get(:@config)[:slaves].each_key do |slave_name|
+      eval <<-EOM
+        def with_#{slave_name}(&block)
+          Thread.current[:with_#{slave_name}_count] ||= 0
+          Thread.current[:with_#{slave_name}_count] += 1
+          yield
+        ensure
+          Thread.current[:with_#{slave_name}_count] -= 1
+        end
+      EOM
+    end if ActiveRecord::Base.connection.instance_variable_get(:@config)[:slaves]
+
+    def connection_with_slave_db_scope
+      slaves.each_key do |slave_name|
+        if Thread.current[:"with_#{slave_name}_count"].to_i > 0
+          return connection_without_slave_db_scope
+        end
+      end
+      connection_without_read_from_slave
+    end
+
     def connection_with_read_from_slave
       normal_connection = connection_without_read_from_slave
       if Thread.current[:read_from_slave] && normal_connection.open_transactions == 0
-        Thread.current[:read_from_slave_uses] = :slave  # for testing use
-        slave_connection
+        slaves.each do |slave_name, slave_config|
+          if Thread.current[:"with_#{slave_name}_count"].to_i > 0
+            Thread.current[:read_from_slave_uses] = slave_name  # for testing use
+            return slave_connection(slave_config)
+          end
+        end
+        # If we're not in a with_slave block, default to the primary slave
+        Thread.current[:read_from_slave_uses] = primary_slave_name  # for testing use
+        return slave_connection(primary_slave_config)
       else
         Thread.current[:read_from_slave_uses] = :master
-        normal_connection
+        return normal_connection
       end
     end
 
-    # Returns a connection to the slave database, or to the regular database if                     
-    # no slave is configured                                                                        
-    #                                                                                               
-    def slave_connection
-      (@slave_model || slave_model).connection_without_read_from_slave
+    # Returns a connection to the slave database, or to the regular database if
+    # no slave is configured
+    #
+    def slave_connection(slave_config)
+      @slave_model ||= {}
+      (@slave_model[slave_config] || slave_model(slave_config)).connection_without_read_from_slave
     end
 
 
-    # Returns an AR model class that has a connection to the appropriate slave db                   
-    #                                                                                               
-    def slave_model
-      db_name = master_database_name
-      if slave_config_for(db_name)
-        unless @@slave_models[db_name]
-          slave_model_name = "ReadFromSlaveFor_#{db_name}"
-          @@slave_models[db_name] = eval %{
+    # Returns an AR model class that has a connection to the appropriate slave db
+    #
+    def slave_model(slave_config)
+      if slave_config_for(slave_config)
+        unless @@slave_models[slave_config]
+          slave_model_name = "ReadFromSlaveFor_#{slave_config}"
+          @@slave_models[slave_config] = eval %{
             class #{slave_model_name} < ActiveRecord::Base
               self.abstract_class = true
-              establish_slave_connection_for('#{db_name}')
+              establish_slave_connection_for('#{slave_config}')
             end
             #{slave_model_name}
           }
         end
-        @slave_model = @@slave_models[db_name]
+        @slave_model[slave_config] = @@slave_models[slave_config]
       else
-        @slave_model = self
+        @slave_model[slave_config] = self
       end
     end
 
-    # Returns the name of the database in use, as given in the database.yml file                    
-    #                                                                                               
-    def master_database_name
-      connection_without_read_from_slave.instance_variable_get(:@config)[:database]
+    #    # Returns the name of the database in use, as given in the database.yml file
+    #    #
+    #    def master_database_name
+    #      connection_without_read_from_slave.instance_variable_get(:@config)[:database]
+    #    end
+
+    # Returns a hash of the slave databases, as given in the database.yml file
+    def slaves
+      connection_without_read_from_slave.instance_variable_get(:@config)[:slaves] || {}
+    end
+
+    # Returns the first slave defined in database.yml which will be used by default for reads
+    def primary_slave_config
+      slaves[primary_slave_name]
     end
 
-    # Returns the config for the associated slave database for this master, 
-    # as given in the database.yml file                    
-    #                                                                                               
-    def slave_config_for(master)
-      configurations["slave_for_#{master}"]
+    # Returns the first slave defined in database.yml which will be used by default for reads
+    def primary_slave_name
+      :primary_slave
     end
 
-    # Establishes a connection to the slave database that is configured for                         
-    # the database name provided                                                                    
-    #                                       
-    def establish_slave_connection_for(master)
-      conn_spec = slave_config_for(master)
+    # Returns the config for the associated slave database for this master,
+    # as given in the database.yml file
+    #
+    def slave_config_for(slave_config)
+      configurations[slave_config]
+    end
+
+    # Establishes a connection to the slave database that is configured for
+    # the database name provided
+    #
+    def establish_slave_connection_for(slave_config)
+      conn_spec = slave_config_for(slave_config)
       establish_connection(conn_spec) if conn_spec
     end
 
     # Re-establishes connections to all the slave databases that
-    # have been used so far.  Use this in your 
+    # have been used so far.  Use this in your
     # PhusionPassenger.on_event(:starting_worker_process) block if required.
     #
     def establish_slave_connections
-      @@slave_models.each do |db_name, model|
-        model.establish_slave_connection_for(db_name)
+      @@slave_models.each do |slave_config, model|
+        model.establish_slave_connection_for(slave_config)
       end
     end
   end
-  
+
   module CalculationMethod
     def calculate_with_read_from_slave(*args)
       Thread.current[:read_from_slave] = true
       calculate_without_read_from_slave(*args)
     ensure
-      Thread.current[:read_from_slave] = false      
+      Thread.current[:read_from_slave] = false
     end
   end
 end

data/test/helper.rb

@@ -12,6 +12,7 @@ module ReadFromSlave
         load_models
         load(SCHEMA_ROOT + "/schema.rb")
         require 'test/unit'
+        require File.join(File.dirname(__FILE__), '..', 'lib', 'read_from_slave')
       end
 
       def test_files
@@ -25,49 +26,58 @@ module ReadFromSlave
       private
 
       def setup_constants
-        set_constant('TEST_ROOT') {File.expand_path(File.dirname(__FILE__))}
-        set_constant('SCHEMA_ROOT') {TEST_ROOT + "/schema"}
+        set_constant('TEST_ROOT') { File.expand_path(File.dirname(__FILE__)) }
+        set_constant('SCHEMA_ROOT') { TEST_ROOT + "/schema" }
       end
-      
+
       def make_sqlite_config
         ActiveRecord::Base.configurations = {
-          'rfs' => {
-            :adapter => 'sqlite3',
-            :database => 'test_db',
-            :timeout => 5000
-          },
-          'slave_for_test_db' => {
-            :adapter => 'sqlite3',
-            :database => 'test_db',
-            :timeout => 5000
-          }
+            'rfs' => {
+                :adapter => 'sqlite3',
+                :database => 'test_db',
+                :timeout => 5000,
+                :slaves =>
+                    {:primary_slave => 'primary_slave',
+                     :slave_2 => 'slave_2'
+                    }
+            },
+            'primary_slave' => {
+                :adapter => 'sqlite3',
+                :database => 'test_db',
+                :timeout => 5000
+            },
+            'slave_2' => {
+                :adapter => 'sqlite3',
+                :database => 'test_db',
+                :timeout => 5000
+            }
         }
       end
-      
+
       def load_models
-        test_model_files.each {|f| require File.join(File.dirname(__FILE__), "models", f)}
+        test_model_files.each { |f| require File.join(File.dirname(__FILE__), "models", f) }
       end
 
       def make_sqlite_connection
         ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['rfs'])
       end
-      
+
       def set_constant(constant)
         Object.const_set(constant, yield) unless Object.const_defined?(constant)
       end
-      
+
       def glob(pattern)
         Dir.glob(pattern)
       end
     end
   end
-  
+
   class ActiveRecordTest < Test
     class << self
       def setup
         setup_constants
       end
-      
+
       def test_files
         glob("#{AR_TEST_SUITE}/cases/**/*_test.rb").sort
       end
@@ -79,10 +89,10 @@ module ReadFromSlave
       private
 
       def setup_constants
-        set_constant('MYSQL_DB_USER') {'rails'}
-        set_constant('AR_TEST_SUITE') {find_active_record_test_suite}
+        set_constant('MYSQL_DB_USER') { 'rails' }
+        set_constant('AR_TEST_SUITE') { find_active_record_test_suite }
       end
- 
+
       def find_active_record_test_suite
         ts = ($:).grep(/activerecord/).last.split('/')
         ts.pop

data/test/read_from_slave_test.rb

@@ -4,7 +4,7 @@ ReadFromSlave::Test.setup
 
 class ReadFromSlaveTest < ActiveSupport::TestCase
   test "slave connection should be different from normal connection" do
-    assert_not_equal Course.connection_without_read_from_slave, Course.slave_connection
+    assert_not_equal Course.connection_without_read_from_slave, Course.slave_connection(Course.primary_slave_config)
   end
 
   test "should be able to write and read from database" do
@@ -21,7 +21,7 @@ class ReadFromSlaveTest < ActiveSupport::TestCase
   test "should read from slave" do
     Course.create(:name=>"Saw playing")
     x = Course.find(:first)
-    assert_equal :slave, Thread.current[:read_from_slave_uses]
+    assert_equal :primary_slave, Thread.current[:read_from_slave_uses]
   end
 
   test "should reload from master" do
@@ -32,9 +32,9 @@ class ReadFromSlaveTest < ActiveSupport::TestCase
   end
 
   test "should get new slave connection when calling establish_slave_connections" do
-    conn = Course.slave_connection
+    conn = Course.slave_connection(Course.primary_slave_config)
     ActiveRecord::Base.establish_slave_connections
-    assert_not_equal conn, Course.slave_connection
+    assert_not_equal conn, Course.slave_connection(Course.primary_slave_config)
   end
 
   test "should not get new master connection when calling establish_slave_connections" do
@@ -44,8 +44,33 @@ class ReadFromSlaveTest < ActiveSupport::TestCase
   end
   
   test "count should use the slave" do
+    count = Course.count
     Course.create(:name=>"Saw playing")
-    assert_equal 1, Course.count
-    assert_equal :slave, Thread.current[:read_from_slave_uses]
+    assert_equal count + 1, Course.count
+    assert_equal :primary_slave, Thread.current[:read_from_slave_uses]
+  end
+
+  test "primary_slave_config should return the right configuration" do
+    assert_equal 'primary_slave', Course.primary_slave_config
+  end
+
+  test "slave is not used by default when all_reads_on_slave is false" do
+    ReadFromSlave.all_reads_on_slave = false
+    Course.create(:name=>"Saw playing")
+    assert_equal :master, Thread.current[:read_from_slave_uses]
+    Course.first
+    assert_equal :master, Thread.current[:read_from_slave_uses]
+  end
+
+  test "correct slave is used with block" do
+    Course.create(:name=>"Saw playing")
+    Course.with_primary_slave do
+      Course.first
+      assert_equal :primary_slave, Thread.current[:read_from_slave_uses]
+    end
+    Course.with_slave_2 do
+      Course.first
+      assert_equal :slave_2, Thread.current[:read_from_slave_uses]
+    end
   end
 end

data/test/setup.rb

@@ -4,4 +4,3 @@ require 'rubygems'
 #gem 'activerecord', '= 2.3.8'
 
 require 'active_record'
-require File.join(File.dirname(__FILE__), '..', 'lib', 'read_from_slave')

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: read_from_slave
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 11
   prerelease: false
   segments: 
   - 0
-  - 4
+  - 5
   - 0
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Stephen Sykes
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-14 00:00:00 +03:00
+date: 2011-06-01 00:00:00 +03:00
 default_executable: 
 dependencies: []