google-cloud-gemserver 0.1.0

data/lib/google/cloud/gemserver/cli/server.rb

@@ -0,0 +1,337 @@
+# Copyright 2017 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#  https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "google/cloud/gemserver"
+require "fileutils"
+require "yaml"
+
+module Google
+  module Cloud
+    module Gemserver
+      class CLI
+
+        ##
+        # # Server
+        #
+        # Object responsible for deploying the gemserver to Google Cloud
+        # Platform and starting it.
+        #
+        class Server
+
+          ##
+          # The Configuration object used to deploy the gemserver
+          # @return [Configuration]
+          attr_reader :config
+
+          ##
+          # Creates a Server instance by initializing a Configuration object
+          # that will be used to access paths to necessary configuration files.
+          def initialize
+            @config = Configuration.new
+          end
+
+          ##
+          # Starts the gemserver by starting up the gemstash server with
+          # predefined options.
+          def start
+            path = if ENV["APP_ENV"] == "production"
+                     Configuration::GAE_PATH
+                   else
+                     @config.config_path
+                   end
+            args = [
+              "start",
+              "--no-daemonize",
+              "--config-file=#{path}"
+            ].freeze
+            Google::Cloud::Gemserver::Backend::StorageSync.download_service
+            Google::Cloud::Gemserver::Backend::GemstashServer.start args
+          end
+
+          ##
+          # Deploys the gemserver to Google Cloud Platform if the app
+          # environment variable is set to "production." Otherwise, the
+          # gemserver is started locally.
+          def deploy
+            begin
+              return start if ["test", "dev"].include? ENV["APP_ENV"]
+              deploy_to_gae
+              setup_default_keys
+            ensure
+              cleanup
+            end
+          end
+
+          ##
+          # Updates the gemserver on a Google Cloud Platform project by
+          # redeploying it.
+          def update
+            return unless Configuration.deployed?
+            puts "Updating gemserver..."
+            deploy_to_gae
+          end
+
+          ##
+          # Deletes a given gemserver by its parent project's ID.
+          #
+          # @param [String] proj_id The project ID of the project the gemserver
+          # was deployed to.
+          def delete proj_id
+            return unless Configuration.deployed?
+            full_delete = user_input("This will delete the entire Google Cloud"\
+               " Platform project #{proj_id}. Continue"\
+               " deletion? (Y|n, default n) If no, all relevant resources will"\
+               " be deleted besides the parent GCP project.").downcase
+            if full_delete == "y"
+              puts "Deleting gemserver with parent project"
+              system "gcloud projects delete #{proj_id}"
+            else
+              @config.delete_from_cloud
+              del_gcs_files
+              inst = @config.app["beta_settings"]["cloud_sql_instances"]
+                .split(":").pop
+              puts "Deleting child Cloud SQL instance #{inst}..."
+              params = "delete #{inst} --project #{proj_id}"
+              status = system "gcloud beta sql instances #{params}"
+              fail "Unable to delete instance" unless status
+              puts "The Cloud SQL instance has been deleted. Visit:\n "\
+                "https://console.cloud.google.com/appengine/settings?project="\
+                "#{proj_id} and click \"Disable Application\" to delete the "\
+                "Google App Engine application the gemserver was deployed to."
+            end
+          end
+
+          private
+
+          ##
+          # Deploys the gemserver to Google App Engine and uploads the
+          # configuration file used by the gemserver to Google Cloud Storage
+          # for later convenience.
+          def deploy_to_gae
+            puts "Beginning gemserver deployment..."
+            prepare_dir
+            path = "#{Configuration::SERVER_PATH}/app.yaml"
+            flags = "-q --project #{@config[:proj_id]}"
+            status = system "gcloud app deploy #{path} #{flags}"
+            fail "Gemserver deployment failed. " unless status
+            wait_until_server_accessible
+            @config.save_to_cloud
+            display_next_steps
+          end
+
+          ##
+          # @private Deletes all gem data files on Google Cloud Storage.
+          def del_gcs_files
+            puts "Deleting all gem data on Google Cloud Storage..."
+            gem_files = GCS.files Configuration::GEMSTASH_DIR
+            gem_files.each { |f| f.delete }
+          end
+
+          ##
+          # @private Creates a key with all permissions and sets it in the
+          # necessary configurations (gem credentials and bundle config).
+          def setup_default_keys
+            should_create = user_input("Would you like to setup a default " \
+              "key? [Y/n] (default yes)")
+            return if should_create.downcase == "n"
+            gemserver_url = remote
+            res = Request.new(gemserver_url).create_key
+            abort "Error generating key" unless res.code.to_i == 200
+            key = Backend::Key.send :parse_key, res.body
+            abort "Invalid key" unless valid_key? key
+            puts "Generated key: #{key}"
+            set_bundle key, gemserver_url
+            set_gem_credentials key
+          end
+
+          ##
+          # @private Sets a given key in the bundle config used by bundler for
+          # installing gems.
+          #
+          # @param [String] key The key to be added to the bundle config.
+          # @param [String] gemserver_url The URL of the gemserver.
+          def set_bundle key, gemserver_url
+            puts "Updating bundle config"
+            run_cmd "bundle config http://#{gemserver_url}/private #{key}"
+          end
+
+          ##
+          # @private Sets a given key in the gem credentials file used by
+          # Rubygems.org
+          #
+          # @param [String] key The key to be added to the credentials.
+          def set_gem_credentials key
+            key_name = sanitize_name(user_input("Updating bundle config. Enter"\
+              " a name for your key (default is \"master-gemserver-key\""))
+            key_name = key_name.empty? == true ? Configuration::DEFAULT_KEY_NAME : key_name
+            puts "Updating #{Configuration::CREDS_PATH}"
+
+            FileUtils.touch Configuration::CREDS_PATH
+            keys = YAML.load_file(Configuration::CREDS_PATH) || {}
+
+            if keys[key_name.to_sym].nil?
+              system "echo \":#{key_name}: #{key}\" >> #{Configuration::CREDS_PATH}"
+            else
+              puts "The key name \"#{key_name}\" already exists. Please update"\
+                " #{Configuration::CREDS_PATH} manually to replace the key or" \
+                " manually enter a different name into the file for your key:" \
+                " #{key}."
+            end
+          end
+
+          ##
+          # @private Checks if a key is valid by its length and value.
+          #
+          # @param [String] key The key to be validated.
+          #
+          # @return [Boolean]
+          def valid_key? key
+            size = key.size == Backend::Key::KEY_LENGTH
+            m_size = key.gsub(/[^0-9a-z]/i, "").size == Backend::Key::KEY_LENGTH
+            size && m_size
+          end
+
+          ##
+          # @private Sanitizes a name by removing special symbols and ensuring
+          # it is alphanumeric (and hyphens, underscores).
+          #
+          # @param [String] name The name to be sanitized.
+          #
+          # @return [String]
+          def sanitize_name name
+            name = name.chomp
+            name.gsub(/[^0-9a-z\-\_]/i, "")
+          end
+
+          ##
+          # @private Outputs helpful information to the console indicating the
+          # URL the gemserver is running at and how to use the gemserver.
+          def display_next_steps
+            puts "\nThe gemserver has been deployed! It is running on #{remote}"
+            puts "\nTo see the status of the gemserver, visit: \n" \
+              " #{remote}/health"
+            puts "\nTo see how to use your gemserver to push and download " \
+              "gems read https://github.com/GoogleCloudPlatform/google-cloud-" \
+              "gemserver/blob/master/docs/usage_example.md for some examples."
+            puts "\nFor general information, visit https://github.com/" \
+              "GoogleCloudPlatform/google-cloud-gemserver/blob/master/README.md"
+          end
+
+          ##
+          # @private Pings the gemserver until a timeout or the gemserver
+          # replies with a 200 response code.
+          #
+          # @param [Integer] timeout The length of time the gemserver is
+          # pinged. Optional.
+          def wait_until_server_accessible timeout = 60
+            puts "Waiting for the gemserver to be accessible..."
+            start_time = Time.now
+            loop do
+              if Time.now - start_time > timeout
+                fail "Could not establish a connection to the gemserver"
+              else
+                r = Request.new(nil, @config[:proj_id]).health
+                break if r.code.to_i == 200
+              end
+              sleep 5
+            end
+          end
+
+          ##
+          # @private The URL of the gemserver.
+          #
+          # @return [String]
+          def remote
+            flag = "--project #{@config[:proj_id]}"
+            descrip = YAML.load(run_cmd "gcloud app describe #{flag}")
+            descrip["defaultHostname"]
+          end
+
+          ##
+          # @private The Gemfile used by the gemserver on Google App Engine.
+          #
+          # @return [String]
+          def gemfile_source
+            <<~SOURCE
+              source "https://rubygems.org"
+
+              gem "google-cloud-gemserver", "#{Google::Cloud::Gemserver::VERSION}", path: "."
+              gem "concurrent-ruby", require: "concurrent"
+              gem "gemstash", git: "https://github.com/bundler/gemstash.git", ref: "a5a78e2"
+              gem "mysql2", "~> 0.4"
+              gem "filelock", "~> 1.1.1"
+              gem "google-cloud-storage", "~> 1.1.0"
+              gem "google-cloud-resource_manager", "~> 0.24"
+              gem "activesupport", "~> 4.2"
+            SOURCE
+          end
+
+          ##
+          # @private Creates a Gemfile and Gemfile.lock for the gemserver that
+          # runs on Google App Engine such that gemstash is not required
+          # client side for the CLI.
+          def gemfile
+            File.open("#{Configuration::SERVER_PATH}/Gemfile", "w") do |f|
+              f.write gemfile_source
+            end
+
+            require "bundler"
+            Bundler.with_clean_env do
+              run_cmd "cd #{Configuration::SERVER_PATH} && bundle lock"
+            end
+          end
+
+          ##
+          # @private Creates a temporary directory with the necessary files to
+          # deploy the gemserver.
+          def prepare_dir
+            dir = Gem::Specification.find_by_name(Configuration::GEM_NAME).gem_dir
+            cleanup if Dir.exist? Configuration::SERVER_PATH
+            FileUtils.mkpath Configuration::SERVER_PATH
+            FileUtils.cp_r "#{dir}/.", Configuration::SERVER_PATH
+            FileUtils.cp @config.config_path, Configuration::SERVER_PATH
+            FileUtils.cp @config.app_path, Configuration::SERVER_PATH
+            gemfile
+          end
+
+          ##
+          # @private Deletes the temporary directory containing the files used
+          # to deploy the gemserver.
+          def cleanup
+            FileUtils.rm_rf Configuration::SERVER_PATH
+          end
+
+          ##
+          # @private Runs a given command on the local machine.
+          #
+          # @param [String] args The command to be run.
+          def run_cmd args
+            `#{args}`
+          end
+
+          ##
+          # @private Gets input from the user after displaying a message.
+          #
+          # @param [String] msg The message to be displayed.
+          #
+          # @return [String]
+          def user_input msg
+            puts msg
+            STDIN.gets.chomp
+          end
+        end
+      end
+    end
+  end
+end

data/lib/google/cloud/gemserver/configuration.rb

@@ -0,0 +1,505 @@
+# Copyright 2017 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#  https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "fileutils"
+require "yaml"
+require "active_support/core_ext/hash/deep_merge"
+
+module Google
+  module Cloud
+    module Gemserver
+      ##
+      #
+      # # Configuration
+      #
+      # Stores configurations for the gemserver and provides methods for
+      # altering that configuration.
+      #
+      class Configuration
+        ##
+        # Default configuration settings for the production database.
+        PROD_DB_DEFAULTS = {
+            database: "mygems",
+            username: "test",
+            password: "test",
+            host: "localhost",
+            socket: "# this will be set automatically"
+        }.freeze
+
+        ##
+        # Default configuration settings for the dev database.
+        DEV_DB_DEFAULTS = {
+            database: "mygems",
+            username: "test",
+            password: "test",
+            host: "localhost",
+            socket: "# this will need to be set manually"
+        }.freeze
+
+        ##
+        # Default configuration settings for the test database.
+        TEST_DB_DEFAULTS = {
+            database: "testgems",
+            username: "test",
+            password: "test",
+            host: "localhost",
+        }.freeze
+
+        ##
+        # Beta setting used by Google App Engine to connect to the Cloud SQL
+        # instance.
+        BETA_SETTING_DEFAULTS = {
+          "cloud_sql_instances" => "# automatically set"
+        }.freeze
+
+        ##
+        # Setting used by Google App Engine to disable health checks for
+        # faster deploys.
+        HEALTH_CHECK_DEFAULT = {
+          "enable_health_check" => false
+        }.freeze
+
+        ##
+        # Setting used by Google App Engine to enable auto scaling.
+        AUTO_SCALING_DEFAULT = {
+          "min_num_instances" => 1,
+          "max_num_instances" => 5
+        }.freeze
+
+        ##
+        # Default configuration settings for the production gemserver.
+        DEFAULT_CONFIG = {
+          db_connection_options: PROD_DB_DEFAULTS,
+          db_adapter: "cloud_sql",
+          cache_type: "memory",
+          protected_fetch: true,
+          bind: "tcp://0.0.0.0:8080",
+          :log_file => :stdout
+        }.freeze
+
+        ##
+        # Default configuration settings for the development gemserver.
+        DEFAULT_DEV_CONFIG = {
+          db_connection_options: DEV_DB_DEFAULTS,
+          db_adapter: "cloud_sql",
+          cache_type: "memory",
+          protected_fetch: true,
+          bind: "tcp://0.0.0.0:8080",
+          :log_file => :stdout
+        }.freeze
+
+        ##
+        # Default configuration settings for the test gemserver.
+        DEFAULT_TEST_CONFIG = {
+          db_connection_options: TEST_DB_DEFAULTS,
+          db_adapter: "sqlite3",
+          cache_type: "memory",
+          protected_fetch: true,
+          bind: "tcp://0.0.0.0:8080",
+          :log_file => :stdout
+        }.freeze
+
+        ##
+        # Prefix for all general configuration setting fields in app.yaml.
+        CONFIG_PREFIX = "gen".freeze
+
+        ##
+        # Prefix for all database configuration setting fields in app.yaml.
+        CONFIG_DB_PREFIX = "db".freeze
+
+        ##
+        # Environment variables used by app.yaml for gemserver deployment.
+        APP_ENGINE_ENV_VARS = {
+          "GEMSERVER_ON_APPENGINE" => true,
+          "production_db_database" => "mygems",
+          "production_db_username" => "test",
+          "production_db_password" => "test",
+          "production_db_host" => "localhost",
+          "production_db_socket" => "# this is set automatically",
+          "production_db_adapter" => "cloud_sql",
+          "dev_db_database" => "mygems",
+          "dev_db_username" => "test",
+          "dev_db_password" => "test",
+          "dev_db_host" => "localhost",
+          "dev_db_socket" => "# this must be set manually",
+          "dev_db_adapter" => "cloud_sql",
+          "test_db_database" => "mygems",
+          "test_db_username" => "test",
+          "test_db_password" => "test",
+          "test_db_host" => "localhost",
+          "test_db_adapter" => "sqlite3",
+          "gen_cache_type" => "memory",
+          "gen_protected_fetch" => true,
+          "gen_bind" => "tcp://0.0.0.0:8080",
+          "gen_log_file" => :stdout
+        }.freeze
+
+        ##
+        # Default settings for gemserver deployment to Google App Engine via
+        # app.yaml.
+        APP_DEFAULTS = {
+          "runtime" => "ruby",
+          "env" => "flex",
+          "entrypoint" => "./bin/google-cloud-gemserver start",
+          "beta_settings" => BETA_SETTING_DEFAULTS,
+          "health_check" =>  HEALTH_CHECK_DEFAULT,
+          "automatic_scaling" => AUTO_SCALING_DEFAULT,
+          "env_variables" => APP_ENGINE_ENV_VARS
+        }.freeze
+
+        ##
+        # @private Temporary directory created to prepare a gemserver deploy
+        # to a Google Cloud Platform project.
+        SERVER_PATH = File.join("/tmp", "google-cloud-gemserver").freeze
+
+        ##
+        # @private Path to the configuration file on Google Cloud Storage that
+        # was last used for a gemserver deploy. This path is checked by the
+        # `config` command to display the last deployed gemserver's
+        # configuration.
+        GCS_PATH    = "#{SERVER_PATH}/config.yml".freeze
+
+        ##
+        # @private The path to the app folder on a deployed gemserver.
+        GAE_DIR     = "/app".freeze
+
+        ##
+        # @private The path to the configuration file on a deployed gemserver.
+        GAE_PATH    = File.join(GAE_DIR, "config.yml").freeze
+
+        ##
+        # @private The path to the credentials file used by the `gem` command.
+        CREDS_PATH = File.expand_path(File.join("~", ".gem", "credentials"))
+          .freeze
+
+        ##
+        # @private Base directory containing configuration files.
+        CONFIG_DIR  = File.expand_path(File.join("~", ".google_cloud_gemserver"))
+
+        ##
+        # The name of the gem.
+        GEM_NAME    = "google-cloud-gemserver".freeze
+
+        ##
+        # @private The default name of the gemserver key.
+        DEFAULT_KEY_NAME = "master-gemserver-key".freeze
+
+        ##
+        # @private The path gem data is stored
+        GEMSTASH_DIR = "/root/.gemstash".freeze
+
+        ##
+        # The configuration used by the gemserver.
+        # @return [Hash]
+        attr_accessor :config
+
+        ##
+        # The configuration used by gcloud to deploy the gemserver to Google
+        # App Engine.
+        # @return [Hash]
+        attr_accessor :app
+
+        ##
+        # Instantiate a new instance of Configuration
+        def initialize
+          @app    = load_app
+          @config = load_config
+        end
+
+        ##
+        # Saves the configuration file used for a deployment.
+        def save_to_cloud
+          puts "Saving configuration"
+          GCS.upload config_path, GCS_PATH
+        end
+
+        ##
+        # Deletes the configuration file used for a deployment
+        def delete_from_cloud
+          GCS.delete_file GCS_PATH
+        end
+
+        ##
+        # Updates the configuration file.
+        #
+        # @param [String] value New value of the key.
+        # @param [String] key Name of the key that will be updated.
+        # @param [String] sub_key Name of the sub key that will be updated.
+        def update_config value, key, sub_key = nil
+          if sub_key
+            @config[key][sub_key] = value
+          else
+            @config[key] = value
+          end
+          write_config
+        end
+        # Updates the app configuration file.
+        #
+        # @param [String] value New value of the key.
+        # @param [String] key Name of the key that will be updated.
+        # @param [String] sub_key Name of the sub key that will be updated.
+        def update_app value, key, sub_key = nil
+          if sub_key
+            @app[key][sub_key] = value
+          else
+            @app[key] = value
+          end
+          write_app
+        end
+
+        ##
+        # Accesses a key in the Configuration object.
+        #
+        # @param [String] key Name of the key accessed.
+        #
+        # @return [String]
+        def [] key
+          @config[key]
+        end
+
+        ##
+        # @private Generates a set of configuration files for the gemserver to
+        # run and deploy to Google App Engine.
+        def gen_config
+          return if on_appengine
+          FileUtils.mkpath config_dir unless Dir.exist? config_dir
+
+          write_file "#{config_dir}/app.yaml",        app_config, true
+          write_file "#{config_dir}/config.yml",      prod_config
+          write_file "#{config_dir}/dev_config.yml",  dev_config
+          write_file "#{config_dir}/test_config.yml", test_config
+        end
+
+        ##
+        # Fetches the path to the relevant configuration file based on the
+        # environment (production, test, development).
+        #
+        # @return [String]
+        def config_path
+          "#{config_dir}/#{suffix}"
+        end
+
+        ##
+        # Fetches the path to the relevant app configuration file.
+        #
+        # @return [String]
+        def app_path
+          "#{config_dir}/app.yaml"
+        end
+
+        ##
+        # Displays the configuration used by the current gemserver
+        def self.display_config
+          unless deployed?
+            puts "No configuration found. Was the gemserver deployed?"
+            return
+          end
+          prepare GCS.get_file(GCS_PATH)
+          puts "Gemserver is running with this configuration:"
+          puts YAML.load_file(GCS_PATH).to_yaml
+          cleanup
+        end
+
+        ##
+        # Checks if the gemserver was deployed by the existence of the config
+        # file used to deploy it on a specific path on Google Cloud Storage.
+        #
+        # @return [Boolean]
+        def self.deployed?
+          !GCS.get_file(GCS_PATH).nil?
+        end
+
+        private
+
+        ##
+        # @private Fetches the current environment.
+        #
+        # @return [String]
+        def env
+          ENV["APP_ENV"].nil? == true ? "production" : ENV["APP_ENV"]
+        end
+
+        ##
+        # @private Determines which configuration file to read based on the
+        # environment.
+        #
+        # @return [String]
+        def suffix
+          if env == "dev"
+            "dev_config.yml"
+          elsif env == "test"
+            "test_config.yml"
+          else
+            "config.yml"
+          end
+        end
+
+        ##
+        # @private Writes a given file to a given path.
+        #
+        # @param [String] path The path to write the file.
+        #
+        # @param [String] content The content to be written to the file.
+        #
+        # @param [boolean] check_existence If true, the file is not overwritten
+        # if it already exists. Optional.
+        def write_file path, content, check_existence = false
+          if check_existence
+            return if File.exist? path
+          end
+          File.open(path, "w") do |f|
+            f.write content
+          end
+        end
+
+        ##
+        # @private The default app.yaml configuration formatted in YAML.
+        #
+        # @return [String]
+        def app_config
+          APP_DEFAULTS.merge(load_app).to_yaml
+        end
+
+        ##
+        # @private The default config.yml configuration formatted in YAML
+        # used by the gemserver in the production environment.
+        #
+        # @return [String]
+        def prod_config
+          DEFAULT_CONFIG.deep_merge(extract_config("production")).to_yaml
+        end
+
+        ##
+        # @private The default dev_config.yml configuration formatted in YAML
+        # used by the gemserver in the dev environment.
+        #
+        # @return [String]
+        def dev_config
+          DEFAULT_DEV_CONFIG.deep_merge(extract_config("dev")).to_yaml
+        end
+
+        ##
+        # @private The default test_config.yml configuration formatted in YAML
+        # used by the gemserver in the test environment.
+        #
+        # @return [String]
+        def test_config
+          DEFAULT_TEST_CONFIG.deep_merge(extract_config("test")).to_yaml
+        end
+
+        ##
+        # @private Extracts the gemserver configuration from the app.yaml
+        # environment variables.
+        #
+        # @param [String] pre The prefix of the config fields to extract.
+        #
+        # @return [Hash]
+        def extract_config pre = "production"
+          adapter = pre + "_" + CONFIG_DB_PREFIX + "_adapter"
+          db_config = @app["env_variables"].map do |k, v|
+            # db_adapter is a special case b/c it has the 'db' in its name but is
+            # not a db_connection_options field
+            next unless k.include?(pre) && k != adapter
+            [(k[pre.size + CONFIG_DB_PREFIX.size + 2..k.size - 1]).to_sym, v]
+          end.compact.to_h
+          config = @app["env_variables"].map do |k, v|
+            next unless k.include? CONFIG_PREFIX
+            [(k[CONFIG_PREFIX.size + 1..k.size - 1]).to_sym, v]
+          end.compact.to_h
+          {
+            :db_connection_options => db_config,
+            :db_adapter => @app["env_variables"][adapter]
+          }.deep_merge config
+        end
+
+        ##
+        # @private Loads a configuration file.
+        #
+        # @return [Hash]
+        def load_config
+          extract_config env
+        end
+
+        ##
+        # @private Loads the app configuration file.
+        #
+        # @return [Hash]
+        def load_app
+          return APP_DEFAULTS unless File.exist? app_path
+          YAML.load_file app_path
+        end
+
+        ##
+        # @private Writes the current Configuration object in YAML format
+        # to the relevant configuration file (based on environment) and
+        # updates app.yaml accordingly.
+        def write_config
+          db_key = env + "_" + CONFIG_DB_PREFIX + "_"
+          key = CONFIG_PREFIX + "_"
+          db = @config[:db_connection_options]
+          non_db = @config.reject { |k, v| k == :db_connection_options }
+          formatted_db = db.map { |k, v| [db_key + k.to_s, v] }.to_h
+          formatted_non_db = non_db.map { |k, v| [key + k.to_s, v] }.to_h
+          @app["env_variables"] = @app["env_variables"].merge(
+            formatted_db.merge(formatted_non_db)
+          )
+          File.open(config_path, "w") { |f| YAML.dump @config, f }
+          write_app
+        end
+
+        ##
+        # @private Writes the current app configuration object in YAML format
+        # to the app configuration file.
+        def write_app
+          File.open(app_path, "w") { |f| YAML.dump @app, f }
+        end
+
+        ##
+        # @private Fetches the directory that contains the configuration files.
+        #
+        # @return [String]
+        def config_dir
+          return GAE_DIR if on_appengine
+          dir = ENV["GEMSERVER_CONFIG_DIR"]
+          dir.nil? == true ? CONFIG_DIR : dir
+        end
+
+        ##
+        # @private Determines if the gemserver is running on Google App Engine.
+        #
+        # @return [boolean]
+        def on_appengine
+          !ENV["GEMSERVER_ON_APPENGINE"].nil?
+        end
+
+        ##
+        # @private Creates a temporary directory to download the configuration
+        # file used to deploy the gemserver.
+        def self.prepare file
+          FileUtils.mkpath SERVER_PATH
+          file.download file.name
+        end
+
+        ##
+        # @private Deletes a temporary directory.
+        def self.cleanup
+          FileUtils.rm_rf SERVER_PATH
+        end
+
+        private_class_method :prepare
+        private_class_method :cleanup
+      end
+    end
+  end
+end