defaults for rules to make startup a bit easier

client/src/main/java/com/metamx/druid/client/DruidServerConfig.java

@@ -36,5 +36,6 @@ public abstract class DruidServerConfig
   public abstract long getMaxSize();
 
   @Config("druid.server.tier")
+  @Default("_default_tier")
   public abstract String getTier();
 }

server/src/main/java/com/metamx/druid/db/DatabaseRuleManager.java

@@ -27,11 +27,13 @@ import com.metamx.common.concurrent.ScheduledExecutors;
 import com.metamx.common.lifecycle.LifecycleStart;
 import com.metamx.common.lifecycle.LifecycleStop;
 import com.metamx.common.logger.Logger;
+import com.metamx.druid.master.rules.PeriodLoadRule;
 import com.metamx.druid.master.rules.Rule;
 import org.codehaus.jackson.map.ObjectMapper;
 import org.codehaus.jackson.type.TypeReference;
 import org.joda.time.DateTime;
 import org.joda.time.Duration;
+import org.joda.time.Period;
 import org.skife.jdbi.v2.DBI;
 import org.skife.jdbi.v2.FoldController;
 import org.skife.jdbi.v2.Folder3;
@@ -40,6 +42,7 @@ import org.skife.jdbi.v2.StatementContext;
 import org.skife.jdbi.v2.tweak.HandleCallback;
 
 import java.sql.SQLException;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -50,6 +53,57 @@ import java.util.concurrent.atomic.AtomicReference;
  */
 public class DatabaseRuleManager
 {
+  public static void createDefaultRule(final DBI dbi, final String ruleTable, final ObjectMapper jsonMapper)
+  {
+    try {
+      dbi.withHandle(
+          new HandleCallback<Void>()
+          {
+            @Override
+            public Void withHandle(Handle handle) throws Exception
+            {
+              List<Map<String, Object>> existing = handle.select(
+                  String.format(
+                      "SELECT id from %s where datasource='_default';",
+                      ruleTable
+                  )
+              );
+
+              if (!existing.isEmpty()) {
+                return null;
+              }
+
+              final List<Rule> defaultRules = Arrays.<Rule>asList(
+                  new PeriodLoadRule(
+                      new Period("P5000Y"),
+                      2,
+                      "_default_tier"
+                  )
+              );
+              final String dataSource = "_default";
+              final String version = new DateTime().toString();
+              handle.createStatement(
+                  String.format(
+                      "INSERT INTO %s (id, dataSource, version, payload) VALUES (:id, :dataSource, :version, :payload)",
+                      ruleTable
+                  )
+              )
+                    .bind("id", String.format("%s_%s", dataSource, version))
+                    .bind("dataSource", dataSource)
+                    .bind("version", version)
+                    .bind("payload", jsonMapper.writeValueAsString(defaultRules))
+                    .execute();
+
+              return null;
+            }
+          }
+      );
+    }
+    catch (Exception e) {
+      throw Throwables.propagate(e);
+    }
+  }
+
   private static final Logger log = new Logger(DatabaseRuleManager.class);
 
   private final ObjectMapper jsonMapper;

server/src/main/java/com/metamx/druid/http/MasterMain.java

@@ -125,12 +125,14 @@ public class MasterMain
         configFactory.build(DatabaseSegmentManagerConfig.class),
         dbi
     );
+    final DatabaseRuleManagerConfig databaseRuleManagerConfig = configFactory.build(DatabaseRuleManagerConfig.class);
     final DatabaseRuleManager databaseRuleManager = new DatabaseRuleManager(
         jsonMapper,
         scheduledExecutorFactory.create(1, "DatabaseRuleManager-Exec--%d"),
-        configFactory.build(DatabaseRuleManagerConfig.class),
+        databaseRuleManagerConfig,
         dbi
     );
+    DatabaseRuleManager.createDefaultRule(dbi, databaseRuleManagerConfig.getRuleTable(), jsonMapper);
 
     final ScheduledExecutorService globalScheduledExec = scheduledExecutorFactory.create(1, "Global--%d");
     final MonitorScheduler healthMonitor = new MonitorScheduler(

server/src/main/java/com/metamx/druid/utils/DruidSetup.java

@@ -21,9 +21,11 @@ package com.metamx.druid.utils;
 
 import com.google.common.io.Closeables;
 import com.metamx.common.logger.Logger;
+import com.metamx.druid.db.DatabaseRuleManager;
 import com.metamx.druid.db.DbConnector;
 import com.metamx.druid.db.DbConnectorConfig;
 import com.metamx.druid.initialization.Initialization;
+import com.metamx.druid.jackson.DefaultObjectMapper;
 import com.metamx.druid.zk.PropertiesZkSerializer;
 import org.I0Itec.zkclient.ZkClient;
 import org.I0Itec.zkclient.ZkConnection;
@@ -381,6 +383,7 @@ public class DruidSetup
 
     DbConnector.createSegmentTable(dbConnector.getDBI(), tableName);
     DbConnector.createRuleTable(dbConnector.getDBI(), ruleTableName);
+    DatabaseRuleManager.createDefaultRule(dbConnector.getDBI(), ruleTableName, new DefaultObjectMapper());
   }
 
   /**

server/src/main/resources/static/js/rules-0.0.1.js

 var tiers = [];
-var defaultDatasource = "_mmx_default";
+var defaultDatasource = "_default";
 
 var ruleTypes = [
   "loadByInterval",