naf 1.1.0

data/app/views/naf/record.html.erb

@@ -0,0 +1,46 @@
+<% content_for :body do %>
+  <div id="record">
+    <%= render partial: 'naf/shared/information_container', locals: { record_name: naf_model_name } %>
+
+    <%= naf_generate_back_link %>
+    <% if !naf_generate_edit_link.blank? && !naf_generate_back_link.blank? %>
+      &nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;
+    <% end %>
+    <%= naf_generate_edit_link %>
+
+    <div id="flash_message">
+        <% unless notice.blank? %>
+          <script type='text/javascript'>
+            jQuery("<p id='notice'><%= notice %></p>")
+                .appendTo('#flash_message')
+                .slideDown().delay(5000).slideUp();
+          </script>
+        <% end %>
+    </div>
+
+    <br/>
+    <table id="naf_table_show">
+      <tr>
+        <th>Attribute</th>
+        <th>Value</th>
+      </tr>
+      <tbody>
+        <% @attributes.each do |a| %>
+          <tr>
+            <td scope="row"><%= naf_make_header(a.to_s) %></td>
+            <td> <%= @record.send(a) %></td>
+          </tr>
+        <% end %>
+      </tbody>
+    </table>
+    <br/>
+
+    <%= naf_generate_child_resources_link %>
+    <% if !naf_generate_destroy_link.blank? && !naf_generate_child_resources_link.blank? %>
+      &nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;
+    <% end %>
+    <%= naf_generate_destroy_link %>
+  </div>
+<% end %>
+
+<%= render partial: 'naf/shared/application' %>

data/app/views/naf/shared/_application.html.erb

@@ -0,0 +1,50 @@
+<div id='naf'>
+  <div id="fluid">
+    <div id='hd'>
+      <div id="header">
+        <h3><%= link_to Naf.title.html_safe, naf.root_url %></h3>
+      </div>
+    </div>
+    <div id="navigation">
+      <ul id="tabs">
+        <% naf_tabs.each_key do |tab| %>
+            <% if naf_highlight_tab?(tab) %>
+                <li id="on">
+            <% else %>
+                <li>
+            <% end %>
+            <%= naf_generate_index_link(tab) %>
+            </li>
+        <% end %>
+      </ul>
+      <div class="clear"></div>
+    </div>
+    <div id='bd'>
+      <% naf_tabs.each do |tab, child_tabs| %>
+          <% if naf_highlight_tab?(tab) && !child_tabs.blank? %>
+            <div id="child_navigation">
+                <ul id="child_tabs">
+                  <% child_tabs.each do |child_tab| %>
+                    <% if naf_highlight_tab?(child_tab) %>
+                      <li id="on">
+                    <% else %>
+                      <li>
+                  <% end %>
+                  <%= naf_generate_index_link(child_tab) %>
+                  </li>
+                  <% end %>
+                </ul>
+                <div class="clear"></div>
+            </div>
+            <div id='child_bd'>
+              <% @naf_render_body = true %>
+              <%= yield :body %>
+            </div>
+          <% end %>
+      <% end %>
+      <% unless @naf_render_body %>
+        <%= yield :body %>
+      <% end %>
+    </div>
+  </div>
+</div>

data/app/views/naf/shared/_information_container.html.erb

@@ -0,0 +1,19 @@
+<div id='page-label'>
+  <h3 id="record_name"><%= record_name %> </h3>
+</div>
+
+<% if current_page?(naf.root_url) or current_page?(action: 'index') %>
+  <% if flash[:error] -%>
+    <div class="error"><%= flash[:error] %></div></br>
+  <% end -%>
+
+  <div id='create_links'>
+    <span id="create">  <%= naf_generate_create_link %> </span>
+  </div>
+<% end %>
+
+<% if naf_nested_resource_index? %>
+  <div id='parent_links'>
+    <span id="parent"> <%= naf_parent_resource_link %> </span>
+  </div>
+<% end %>

data/app/views/naf/shared/_select_per_page.html.erb

@@ -0,0 +1,72 @@
+<% content_for :javascripts do %>
+  <script type='text/javascript'>
+
+    function initPageSelect() {
+      var pageSelect = jQuery('#page-select-container');
+      var refreshPage = jQuery('#refresh-page-container');
+      jQuery('#datatable_paginate').append(pageSelect).append(refreshPage);
+      pageSelect.show();
+      refreshPage.show();
+    }
+
+    function getDisplayLength() {
+      return parseInt(jQuery('#iDisplayLength').val());
+    }
+
+    // Global to store the current timeout id value.
+    var timeout_id = null;
+
+    // Redraw datatable.
+    var redrawDatatable = function() {
+      jQuery("#datatable").dataTable().fnDraw(false);
+      if ( jQuery('#auto_refresh').is(':checked') ) {
+        timeout_id = setTimeout(redrawDatatable, 10000);
+      }
+    };
+
+    jQuery(document).ready(function() {
+      jQuery('#page-select-container form select').change(function() {
+        var ddTable = jQuery('#datatable');
+        ddTable.dataTableSettings[0]._iDisplayStart = 0;
+        ddTable.dataTableSettings[0]._iDisplayLength = parseInt(this.value);
+        jQuery('#datatable').dataTable().fnDraw();
+      });
+
+      <% if controller_name == 'historical_jobs' %>
+        timeout_id = setTimeout(redrawDatatable, 10000);
+        jQuery('#auto_refresh').prop('checked', true);
+      <% end %>
+
+      jQuery('#refresh_datatable').click(function(){
+        jQuery('#datatable').dataTable().fnDraw();
+      });
+
+      // Set change event to enabled/disable auto-refresh
+      jQuery('#auto_refresh').change(function() {
+        if ( jQuery(this).is(':checked') ) {
+          timeout_id = setTimeout(redrawDatatable, 10000);
+        } else {
+          clearTimeout(timeout_id);
+          timeout_id = null;
+        }
+      });
+    });
+
+  </script>
+<% end %>
+
+<div id='refresh-page-container'>
+  <%= link_to "Refresh Table", "#", id: :refresh_datatable %>
+  &nbsp;&nbsp;
+  <%= label_tag :auto_refresh, 'Auto Refresh:' %>
+  <%= check_box_tag :auto_refresh, 1, false, id: :auto_refresh %>
+</div>
+
+<div id="page-select-container" class="ui-state-default ui-corner-all">
+  <%= form_tag({ controller: params[:controller], action: params[:action], format: 'js' }, method: :get) do %>
+    <%= label_tag :iDisplayLength, "Rows Per Page:", class: "label" %>
+    <%= select_tag :iDisplayLength,
+        options_for_select(::Naf.configuration.default_page_options,  @rows_per_page),
+        class: "page-select datatable_variable ui-state-default ui-corner-all" %>
+  <% end %>
+</div>

data/ci/test-build.sh

@@ -0,0 +1,17 @@
+#!/bin/bash -e
+
+echo 'Dropping your naf_development database if it exists'
+
+psql -U postgres -c "drop database if exists naf_development"
+psql -U postgres -c "drop database if exists primary_development"
+
+echo 'Removing existing migration in dummy application'
+
+rm -f spec/dummy/app/models/other/base.rb
+
+rm -rf spec/dummy/db/naf
+
+rm -f spec/dummy/db/migrate/*.rb
+
+./ci/travis.sh
+

data/ci/travis.sh

@@ -0,0 +1,26 @@
+#!/bin/bash -e
+
+rake="bundle exec rake"
+
+cd spec/dummy
+
+# Bring in the initializer
+
+if [ $SPEC_GROUP == 'non_primary_database' ]
+then
+  echo 'Testing non primary database install'
+  cp config/database-non_primary.yml config/database.yml
+  cp app/models/other/base.rb.sample app/models/other/base.rb
+  cp config/initializers/naf.rb.non_primary config/initializers/naf.rb
+  $rake naf:install:migrations naf:isolate:migrations db:create:all naf:db:migrate naf:janitor:infrastructure naf:db:test:clone_structure
+else
+  echo 'Testing primary database install'
+  cp config/database-primary.yml config/database.yml
+  cp config/initializers/naf.rb.primary config/initializers/naf.rb
+  $rake naf:install:migrations db:create db:migrate naf:janitor:infrastructure db:test:clone_structure
+fi
+
+cd ../..
+
+$rake spec
+

data/config/initializers/naf.rb

@@ -0,0 +1,3 @@
+module Naf
+  DEFAULT_PAGE_OPTIONS = [10, 20, 50, 100, 250, 500, 750, 1000, 1500, 2000]
+end

data/config/routes.rb

@@ -0,0 +1,38 @@
+Naf::Engine.routes.draw do
+  resources :historical_jobs do
+    resources :historical_job_affinity_tabs, except: [:destroy]
+  end
+
+  resources :applications, except: [:destroy] do
+    resources :application_schedules, only: [] do
+      resources :application_schedule_affinity_tabs
+    end
+  end
+
+  resources :machines, except: [:destroy] do
+    resources :machine_affinity_slots
+  end
+
+  resources :machine_runners, only: [:index, :show]
+  resources :machine_runner_invocations, only: [:index, :show, :update] do
+    collection do
+      get :wind_down_all
+    end
+  end
+  resources :logger_styles
+  resources :logger_names
+  resources :affinities
+
+  resources :janitorial_archive_assignments, controller: "janitorial_assignments",
+                                             type: "Naf::JanitorialArchiveAssignment",
+                                             except: [:destroy]
+  resources :janitorial_create_assignments, controller: "janitorial_assignments",
+                                            type: "Naf::JanitorialCreateAssignment",
+                                            except: [:destroy]
+  resources :janitorial_drop_assignments, controller: "janitorial_assignments",
+                                          type: "Naf::JanitorialDropAssignment",
+                                          except: [:destroy]
+
+  match "jobs" => "historical_jobs#index"
+  root to: "historical_jobs#index"
+end

data/db/migrate/20120820023848_naf_schema.rb

@@ -0,0 +1,413 @@
+class NafSchema < ActiveRecord::Migration
+
+  def up
+    # Define a schema_name, the scheduling tables fall under:
+    schema_name = Naf.schema_name
+
+    # affinities
+    #  names: normal, canary, perennial
+    #  location: ip address
+    #  application/release on machine: application-release-number
+    execute <<-SQL
+
+      do LANGUAGE plpgsql $$
+        begin
+          if (SELECT count(*) FROM pg_namespace WHERE nspname !~ '^pg_.*' AND nspname NOT IN ('information_schema') AND nspname = '#{schema_name}') > 0 THEN
+            raise notice 'Skipping creation of schema: #{schema_name}, already exists';
+          else
+            raise notice 'Creating new schema #{schema_name}';
+            create schema #{schema_name};
+          end if;
+        end;
+      $$;
+
+      create table #{schema_name}.affinity_classifications
+      (
+          id                             serial not null primary key,
+          created_at                     timestamp not null default now(),
+          updated_at                     timestamp,
+          affinity_classification_name   text not null unique
+      );
+      insert into #{schema_name}.affinity_classifications (affinity_classification_name) values
+        ('location'), ('purpose'), ('application'), ('weight'), ('machine');
+      create table #{schema_name}.affinities
+      (
+          id                            serial not null primary key,
+          created_at                    timestamp not null default now(),
+          updated_at                    timestamp,
+          selectable                    boolean not null default true,
+          affinity_classification_id    integer not null references #{schema_name}.affinity_classifications,
+          affinity_name                 text not null,
+          affinity_short_name           text unique check ( affinity_short_name ~ '^[a-zA-Z_][a-zA-Z0-9_]*$' ),
+          affinity_note                 text null,
+          unique (affinity_classification_id, affinity_name)
+      );
+      insert into #{schema_name}.affinities (affinity_classification_id, affinity_name, affinity_short_name) values
+         ((select id from #{schema_name}.affinity_classifications where affinity_classification_name = 'purpose'), 'normal', 'normal'),
+         ((select id from #{schema_name}.affinity_classifications where affinity_classification_name = 'purpose'), 'canary', 'canary'),
+         ((select id from #{schema_name}.affinity_classifications where affinity_classification_name = 'purpose'), 'perennial', 'perennial'),
+         ((select id from #{schema_name}.affinity_classifications where affinity_classification_name = 'weight'), 'memory', 'memory'),
+         ((select id from #{schema_name}.affinity_classifications where affinity_classification_name = 'weight'), 'cpus', 'cpus');
+      create table #{schema_name}.machines
+      (
+          id                             serial not null primary key,
+          created_at                     timestamp not null default now(),
+          updated_at                     timestamp,
+          server_address                 inet not null unique,
+          server_name                    text,
+          short_name                     text unique check ( short_name ~ '^[a-zA-Z_][a-zA-Z0-9_]*$' ),
+          server_note                    text,
+          enabled                        boolean not null default true,
+          thread_pool_size               integer not null default 5,
+          last_checked_schedules_at      timestamp null,
+          last_seen_alive_at             timestamp null,
+          marked_down                    boolean not null default false,
+          marked_down_by_machine_id      integer null references #{schema_name}.machines,
+          marked_down_at                 timestamp null,
+          log_level                      text null,
+          deleted                        boolean not null default false check (deleted = false OR enabled = false)
+      );
+      create table #{schema_name}.machine_affinity_slots
+      (
+          id                                      serial not null primary key,
+          created_at                              timestamp not null default now(),
+          machine_id			                        integer not null references #{schema_name}.machines,
+          affinity_id                        	    integer not null references #{schema_name}.affinities,
+          affinity_parameter                      numeric null,
+          required                                boolean not null default false,
+          unique (machine_id, affinity_id)
+      );
+      create table #{schema_name}.machine_runners
+      (
+          id                    serial not null primary key,
+          created_at            timestamp not null default now(),
+          machine_id            integer not null references #{schema_name}.machines,
+          runner_cwd            text not null,
+          unique (machine_id, runner_cwd)
+      );
+      create table #{schema_name}.machine_runner_invocations
+      (
+          id                    serial not null primary key,
+          created_at            timestamp not null default now(),
+          updated_at            timestamp,
+          machine_runner_id     integer not null references #{schema_name}.machine_runners,
+          pid                   integer not null,
+          dead_at               timestamp null,
+          wind_down_at          timestamp null,
+          commit_information    text null,
+          branch_name           text null,
+          repository_name       text null,
+          deployment_tag        text null
+      );
+      create table #{schema_name}.application_types
+      (
+          id                  serial not null primary key,
+          created_at          timestamp not null default now(),
+          updated_at          timestamp,
+          enabled             boolean not null default true,
+          script_type_name    text unique not null,
+          description         text,
+          invocation_method   text not null
+      );
+      insert into #{schema_name}.application_types (script_type_name, description, invocation_method) values
+        ('rails', 'ruby on rails NAF application', 'rails_invocator'),
+        ('bash command', 'bash command', 'bash_command_invocator'),
+        ('bash script', 'bash script', 'bash_script_invocator'),
+        ('ruby', 'ruby script', 'ruby_script_invocator');
+      create table #{schema_name}.applications
+      (
+          id                              serial not null primary key,
+          created_at                      timestamp not null default now(),
+          updated_at                      timestamp,
+          deleted                         boolean not null default false,
+          application_type_id	            integer not null references #{schema_name}.application_types,
+          command                         text not null,
+          title                           text not null,
+          short_name                      text null unique check ( short_name ~ '^[a-zA-Z_][a-zA-Z0-9_]*$' ),
+          log_level                       text null
+      );
+      insert into #{schema_name}.applications (application_type_id, command, title) values
+        (
+          (select id from #{schema_name}.application_types where script_type_name = 'rails'),
+          '::Process::Naf::Janitor.run',
+          'Database Janitorial Work'
+        );
+      create table #{schema_name}.application_run_group_restrictions
+      (
+          id                                        serial not null primary key,
+          created_at                                timestamp not null default now(),
+          application_run_group_restriction_name    text unique not null
+      );
+      insert into #{schema_name}.application_run_group_restrictions (application_run_group_restriction_name) values
+         ('no limit'), ('limited per machine'), ('limited per all machines');
+      create table #{schema_name}.application_schedules
+      (
+          id                                       serial not null primary key,
+          created_at                               timestamp not null default now(),
+          updated_at                               timestamp,
+          enabled                                  boolean not null default true,
+          visible                                  boolean not null default true,
+          application_id                           integer unique not null references #{schema_name}.applications,
+          application_run_group_restriction_id     integer not null references #{schema_name}.application_run_group_restrictions,
+          application_run_group_name               text null,
+          application_run_group_limit              integer null check (application_run_group_limit >= 1 or application_run_group_limit is null),
+          run_start_minute                         integer null check (run_start_minute >= 0 and run_start_minute < (24 * 60)),
+          run_interval                             integer null check (run_interval >= 0),
+          priority                                 integer not null default 0,
+          enqueue_backlogs                         boolean not null default false,
+          check (visible = true OR enabled = false),
+          check (run_start_minute is null OR run_interval is null)
+      );
+      insert into #{schema_name}.application_schedules
+        (application_id, application_run_group_restriction_id, application_run_group_name, application_run_group_limit, run_start_minute, run_interval) values
+        (
+          (select id from #{schema_name}.applications where command = '::Process::Naf::Janitor.run'),
+          (select id from #{schema_name}.application_run_group_restrictions where application_run_group_restriction_name = 'limited per all machines'),
+          '::Process::Naf::Janitor.run',
+          1,
+          5,
+          null
+        );
+      create unique index applications_have_one_schedule_udx on #{schema_name}.application_schedules (application_id) where enabled = true;
+      create table #{schema_name}.application_schedule_affinity_tabs
+      (
+          id                                 serial not null primary key,
+          created_at                         timestamp not null default now(),
+          application_schedule_id 	         integer not null references #{schema_name}.application_schedules,
+          affinity_id           	           integer not null references #{schema_name}.affinities,
+          affinity_parameter                 numeric null,
+          UNIQUE (application_schedule_id, affinity_id)
+      );
+      create table #{schema_name}.application_schedule_prerequisites
+      (
+          id                                     serial not null primary key,
+          created_at                             timestamp not null default now(),
+          application_schedule_id                integer not null references #{schema_name}.application_schedules,
+          prerequisite_application_schedule_id   integer not null references #{schema_name}.application_schedules,
+          UNIQUE (application_schedule_id, prerequisite_application_schedule_id),
+          CHECK (application_schedule_id <> prerequisite_application_schedule_id)
+      );
+      create table #{schema_name}.historical_jobs
+      (
+          id                                     bigserial not null primary key,
+          created_at                             timestamp not null default now(),
+          updated_at                             timestamp,
+
+          application_id                         integer null references #{schema_name}.applications,
+          application_type_id                    integer not null references #{schema_name}.application_types,
+          command                                text not null,
+
+          application_run_group_restriction_id   integer not null references #{schema_name}.application_run_group_restrictions,
+          application_run_group_name             text null,
+          application_run_group_limit            integer null default 1,
+
+          priority                               integer not null default 0,
+
+          started_on_machine_id                  integer null references #{schema_name}.machines,
+
+          failed_to_start                        boolean null,
+          started_at                             timestamp null,
+          pid                                    integer null,
+          finished_at                            timestamp null,
+          exit_status                            integer null,
+          termination_signal                     integer null,
+
+          state                                  text null,
+
+          request_to_terminate                   boolean not null default false,
+
+          marked_dead_by_machine_id              integer null references #{schema_name}.machines,
+          marked_dead_at                         timestamp null,
+
+          log_level                              text null,
+          tags                                   text[],
+          machine_runner_invocation_id                      integer null references #{schema_name}.machine_runner_invocations
+      );
+      create table #{schema_name}.historical_job_prerequisites
+      (
+          id                                     bigserial not null primary key,
+          created_at                             timestamp not null default now(),
+          historical_job_id                      bigint not null, -- references #{schema_name}.historical_jobs,
+          prerequisite_historical_job_id         bigint not null, -- references #{schema_name}.historical_jobs,
+          UNIQUE (historical_job_id, prerequisite_historical_job_id),
+          CHECK (historical_job_id <> prerequisite_historical_job_id)
+      );
+      create table #{schema_name}.historical_job_affinity_tabs
+      (
+          id                                     bigserial not null primary key,
+          created_at                             timestamp not null default now(),
+          historical_job_id                      bigint not null, -- references #{schema_name}.historical_jobs,
+          affinity_id                            bigint not null references #{schema_name}.affinities,
+          affinity_parameter                     numeric null,
+          UNIQUE (historical_job_id, affinity_id)
+      );
+      create table #{schema_name}.queued_jobs
+      (
+          id                                     bigint not null primary key, -- references #{schema_name}.historical_jobs
+          created_at                             timestamp not null default now(),
+          updated_at                             timestamp,
+
+          application_id                         integer null references #{schema_name}.applications,
+          application_type_id                    integer not null references #{schema_name}.application_types,
+          command                                text not null,
+
+          application_run_group_restriction_id   integer not null references #{schema_name}.application_run_group_restrictions,
+          application_run_group_name             text null,
+          application_run_group_limit            integer null default 1,
+
+          priority                               integer not null default 0
+      );
+      create table #{schema_name}.running_jobs
+      (
+          id                                     bigint not null primary key, -- references #{schema_name}.historical_jobs
+          created_at                             timestamp not null default now(),
+          updated_at                             timestamp,
+
+          application_id                         integer null references #{schema_name}.applications,
+          application_type_id                    integer not null references #{schema_name}.application_types,
+          command                                text not null,
+
+          application_run_group_restriction_id   integer not null references #{schema_name}.application_run_group_restrictions,
+          application_run_group_name             text null,
+          application_run_group_limit            integer null default 1,
+
+          started_on_machine_id                  integer not null references #{schema_name}.machines,
+
+          started_at                             timestamp null,
+          pid                                    integer null,
+
+          request_to_terminate                   boolean not null default false,
+
+          marked_dead_by_machine_id              integer null references #{schema_name}.machines,
+          marked_dead_at                         timestamp null,
+
+          log_level                              text null
+      );
+      create table #{schema_name}.janitorial_assignments
+      (
+          id                                     serial not null primary key,
+          created_at                             timestamp not null default now(),
+          updated_at                             timestamp,
+          type                                   text not null,
+          enabled                                boolean not null default true,
+          deleted                                boolean not null default false,
+          model_name                             text not null,  -- ::Naf::HistoricalJob
+          assignment_order                       integer not null default 0,
+          check (deleted = false OR enabled = false)
+      );
+      create table #{schema_name}.logger_styles
+      (
+          id                                     serial not null primary key,
+          created_at                             timestamp not null default now(),
+          updated_at                             timestamp,
+          name                                   text not null unique,
+          note                                   text null
+      );
+      create table #{schema_name}.logger_names
+      (
+          id                                     serial not null primary key,
+          created_at                             timestamp not null default now(),
+          updated_at                             timestamp,
+          name                                   text not null unique
+      );
+      create table #{schema_name}.logger_levels
+      (
+          id                                     serial not null primary key,
+          created_at                             timestamp not null default now(),
+          updated_at                             timestamp,
+          level                                  text not null unique
+      );
+      insert into #{schema_name}.logger_levels (level) values
+        ('ALL'),
+        ('DEBUG'),
+        ('DEBUG_FINE'),
+        ('DEBUG_MEDIUM'),
+        ('DEBUG_GROSS'),
+        ('DETAIL'),
+        ('INFO'),
+        ('WARN'),
+        ('ALARM'),
+        ('ERROR'),
+        ('FATAL'),
+        ('OFF');
+      create table #{schema_name}.logger_style_names
+      (
+          id                                     serial not null primary key,
+          created_at                             timestamp not null default now(),
+          updated_at                             timestamp,
+          logger_style_id                        integer not null references #{schema_name}.logger_styles,
+          logger_name_id                         integer not null references #{schema_name}.logger_names,
+          logger_level_id                        integer not null references #{schema_name}.logger_levels,
+          UNIQUE(logger_style_id, logger_name_id)
+      );
+      insert into #{schema_name}.janitorial_assignments (type, assignment_order, model_name) values
+        ('Naf::JanitorialCreateAssignment', 500, '::Naf::HistoricalJob'),
+        ('Naf::JanitorialDropAssignment',   500, '::Naf::HistoricalJob'),
+        ('Naf::JanitorialCreateAssignment', 125, '::Naf::HistoricalJobPrerequisite'),
+        ('Naf::JanitorialDropAssignment',   125, '::Naf::HistoricalJobPrerequisite'),
+        ('Naf::JanitorialCreateAssignment', 250, '::Naf::HistoricalJobAffinityTab'),
+        ('Naf::JanitorialDropAssignment',   250, '::Naf::HistoricalJobAffinityTab');
+
+      set search_path = 'public';
+
+    SQL
+  end
+
+  def down
+    schema_name = Naf.schema_name
+    execute <<-SQL
+      drop table #{schema_name}.janitorial_assignments cascade;
+      drop table #{schema_name}.historical_job_affinity_tabs cascade;
+      drop table #{schema_name}.historical_job_prerequisites cascade;
+      drop table #{schema_name}.historical_jobs cascade;
+      drop table #{schema_name}.running_jobs cascade;
+      drop table #{schema_name}.queued_jobs cascade;
+      drop table #{schema_name}.affinities cascade;
+      drop table #{schema_name}.affinity_classifications cascade;
+      drop table #{schema_name}.machines cascade;
+      drop table #{schema_name}.machine_runner_invocations cascade;
+      drop table #{schema_name}.machine_runners cascade;
+      drop table #{schema_name}.machine_affinity_slots cascade;
+      drop table #{schema_name}.applications cascade;
+      drop table #{schema_name}.application_types cascade;
+      drop table #{schema_name}.application_run_group_restrictions cascade;
+      drop table #{schema_name}.application_schedule_prerequisites cascade;
+      drop table #{schema_name}.application_schedules cascade;
+      drop table #{schema_name}.application_schedule_affinity_tabs cascade;
+      drop table #{schema_name}.logger_levels cascade;
+      drop table #{schema_name}.logger_names cascade;
+      drop table #{schema_name}.logger_styles cascade;
+      drop table #{schema_name}.logger_style_names cascade;
+    SQL
+
+    if schema_name != "public"
+      execute <<-SQL
+        do LANGUAGE plpgsql $$
+          begin
+            if (SELECT COUNT(*) FROM pg_tables WHERE schemaname = '#{schema_name}') > 0 THEN
+              raise notice 'Skipping drop of schema:: #{schema_name}, there are still other tables under it!';
+            else
+              raise notice 'Dropping schema #{schema_name}';
+              drop schema #{schema_name} cascade;
+            end if;
+          end;
+        $$;
+      SQL
+    end
+
+    schemas = execute <<-SQL
+      SELECT 'drop schema ' || nspname ||' cascade;'
+      FROM pg_namespace
+      WHERE nspname = 'naf_historical_job_affinity_tabs_partitions' OR
+        nspname = 'naf_historical_job_prerequisites_partitions' OR
+        nspname = 'naf_historical_jobs_partitions';
+    SQL
+
+    schemas.values.each do |schema|
+      execute <<-SQL
+        #{schema.first}
+      SQL
+    end
+
+  end
+end