nucleus 0.1.0

data/Rakefile

@@ -0,0 +1,137 @@
+import 'tasks/compatibility.rake'
+import 'tasks/evaluation.rake'
+import 'spec/test_suites.rake'
+
+require 'rake'
+require 'rubygems'
+require 'bundler'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rainbow/ext/string' unless String.respond_to?(:color)
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+# first check code style, then execute the tests
+task default: [:rubocop, :spec]
+
+# map spec task to all test suites
+task :spec do
+  # first, run all tests
+  Rake::Task['spec:suite:all'].invoke
+  # if on the CI system, push coverage report to codeclimate
+  if ENV['CODECLIMATE_REPO_TOKEN']
+    require 'simplecov'
+    require 'codeclimate-test-reporter'
+    CodeClimate::TestReporter::Formatter.new.format(SimpleCov.result)
+  end
+end
+
+task :doc_toc do
+  File.open('README.md', 'r') do |f|
+    f.each_line do |line|
+      forbidden_words = ['Table of contents', 'define', 'pragma']
+      next if !line.start_with?('#') || forbidden_words.any? { |w| line =~ /#{w}/ }
+
+      title = line.delete('#').strip
+      href = title.tr(' ', '-').downcase
+      puts '  ' * (line.count('#') - 1) + "* [#{title}](\##{href})"
+    end
+  end
+end
+
+desc 'Record all adapter tests'
+task :record do
+  # http://www.relishapp.com/vcr/vcr/v/2-9-3/docs/record-modes
+  ENV['VCR_RECORD_MODE'] = 'once'
+  # recording only valid for adapter tests
+  Rake::Task['spec:suite:adapters'].invoke
+end
+
+namespace :record do
+  FileList['spec/adapter/v1/**'].each do |file|
+    next unless File.directory?(file)
+    adapter = File.basename(file)
+
+    desc "Record #{adapter} adapter tests"
+    RSpec::Core::RakeTask.new(adapter) do |t|
+      # new_episodes
+      ENV['VCR_RECORD_MODE'] = 'once'
+      t.pattern = "spec/adapter/v1/#{adapter}/*_spec.rb"
+      t.verbose = true
+    end
+  end
+end
+
+task :environment do
+  ENV['RACK_ENV'] ||= 'development'
+  require 'configatron'
+  require 'nucleus/scripts/setup_config'
+  nucleus_config.logging.level = Logger::Severity::ERROR
+  require 'nucleus_api/scripts/load_api'
+  require 'nucleus_api/scripts/initialize_api'
+end
+
+task routes: :environment do
+  Nucleus::API::RootAPI.routes.each do |route|
+    next if route.nil? || route.route_method.nil?
+    method = route.route_method.ljust(10)
+    path = route.route_path
+    version = route.instance_variable_get(:@options)[:version]
+    path = path.gsub(/:version/, version) unless version.nil?
+    puts "    #{method} #{path} - [#{version}]"
+  end
+end
+
+task schema_v1: :environment do
+  require 'json'
+  response = Nucleus::API::RootAPI.call(
+    'REQUEST_METHOD' => 'GET',
+    'PATH_INFO' => '/schema',
+    'rack.input' => StringIO.new)[2].body[0]
+  json = JSON.parse(response)
+  puts JSON.pretty_generate(json)
+end
+
+begin
+  require 'yard'
+  DOC_FILES = %w(lib/**/*.rb)
+
+  YARD::Rake::YardocTask.new(:doc) do |t|
+    t.files = DOC_FILES
+  end
+
+  namespace :doc do
+    YARD::Rake::YardocTask.new(:pages) do |t|
+      t.files = DOC_FILES
+      t.options = ['-o', '../nucleus.doc/docs', '--title', "Nucleus #{Nucleus::VERSION} Documentation"]
+    end
+
+    desc 'Check out gh-pages.'
+    task :checkout do
+      dir = File.join(__dir__, '..', 'nucleus.doc')
+      unless Dir.exist?(dir)
+        Dir.mkdir(dir)
+        Dir.chdir(dir) do
+          system('git init')
+          system('git remote add origin git@github.com:stefan-kolb/nucleus.git')
+          system('git pull')
+          system('git checkout gh-pages')
+        end
+      end
+    end
+
+    desc 'Generate and publish YARD docs to GitHub pages.'
+    task publish: %w(doc:pages:checkout doc:pages) do
+      Dir.chdir(File.join(__dir__, '..', 'nucleus.doc')) do
+        system('git checkout gh-pages')
+        system('git add .')
+        system('git add -u')
+        system("git commit -m 'Generating docs for version #{Nucleus::VERSION}.'")
+        system('git push origin gh-pages')
+      end
+    end
+  end
+rescue LoadError
+  puts 'You need to install YARD.'
+end

data/bin/nucleus

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+
+# set the process name on ps, does not work on OS X due to system limitations
+$0 = 'Nucleus'
+Process.setproctitle('Nucleus') if Process.respond_to?(:setproctitle)
+
+root_dir = File.join(__dir__, '..')
+
+require 'optparse'
+require 'yaml'
+require 'thin'
+
+NUCLEUS_CONFIG_LOCATION = File.join(root_dir, 'config', 'nucleus_config.rb')
+
+options = { env: 'development', logdir: File.join(root_dir, 'log'), config: File.expand_path(NUCLEUS_CONFIG_LOCATION) }
+optparse = OptionParser.new do |opts|
+  opts.banner = <<BANNER
+Usage:
+nucleus [options]
+
+Options:
+BANNER
+  opts.on('-r', '--hostname HOSTNAME', 'Bind to HOST address (default: localhost)') { |host| ENV['NUCLEUS_API_HOST'] = host }
+  opts.on('-p', '--port PORT', 'Use PORT (default: 9292)') { |port| ENV['NUCLEUS_API_PORT'] = port }
+  opts.on('-e', '--env ENV', 'Environment (default: "development")') { |env| options[:env] = env }
+  opts.on('-t', '--timeout TIMEOUT', 'Timeout for single request (default: 30)') { |timeout| ENV['NUCLEUS_API_TIMEOUT'] = timeout }
+  opts.on('-h', '--help', '') { options[:help] = true }
+  opts.separator <<EOS
+
+Daemon options:
+EOS
+  opts.on('-d', '--daemon', 'Run the server as daemon in the background (default: false)') { options[:daemon] = true }
+  opts.on('-u', '--user USER', 'User to run daemon as. Use with -d (default: "nobody")') { |user| options[:user] = user }
+  opts.on('-g', '--group GROUP', 'Group to run daemon as. Use with -d (default: "nobody")') { |group| options[:group] = group }
+  opts.on('-b', '--pid PID', 'File to store PID (default: tmp/pids/thin.pid)') { |pid| options[:pid] = pid }
+  opts.on('-l', '--logdir LOGDIR', "Directory for log files if run as daemon, defaults to #{options[:logdir]}") { |opt| options[:logdir] = opt }
+  opts.separator <<EOS
+
+SSL options:
+EOS
+  opts.on('-s', '--ssl', 'Enable SSL (default: false, use with: ssl-key and ssl-cert)') { options[:ssl] = true }
+  opts.on('-k', '--ssl-key KEY', 'SSL key file to use (use with: ssl and ssl-cert)') { |key| options[:ssl_key] = key }
+  opts.on('-c', '--ssl-cert CERT', 'SSL certificate file to use (use with: ssl and ssl-key)') { |cert| options[:ssl_cert] = cert }
+end
+
+optparse.parse!
+
+if options[:help]
+  puts optparse
+  exit(0)
+end
+
+if options[:env] == 'production' && ( !options.key?(:ssl) || options[:ssl] == false)
+  puts 'You need to use HTTPS when running a production server. Please specify the SSL key and certificate.'
+  exit(201)
+end
+
+if options[:ssl]
+  unless options[:ssl_key]
+    puts "You need to set SSL key using '-k /path/to/keyfile.key'"
+    exit(101)
+  end
+  unless options[:ssl_cert]
+    puts "You need to set SSL certificate using '-c /path/to/certificate.crt'"
+    exit(102)
+  end
+end
+
+ENV['NUCLEUS_API_HOST'] = 'localhost' unless ENV['NUCLEUS_API_HOST']
+ENV['NUCLEUS_API_PORT'] = '9292' unless ENV['NUCLEUS_API_PORT']
+
+argv_opts = ARGV.clone
+argv_opts << ['start'] unless Thin::Runner.commands.include?(options[0])
+argv_opts << ['--address', ENV['NUCLEUS_API_HOST'] ]
+argv_opts << ['--port', ENV['NUCLEUS_API_PORT'] ]
+argv_opts << ['--rackup', File.join(root_dir, 'config.ru') ]
+argv_opts << ['-e', options[:env] ]
+argv_opts << ['--timeout', ENV['NUCLEUS_API_TIMEOUT'] || '60']
+argv_opts << ['--ssl', '--ssl-key-file', options[:ssl_key], '--ssl-cert-file', options[:ssl_cert]] if options[:ssl]
+
+if options[:daemon]
+  options[:env] = 'production'
+  argv_opts << [ '--daemonize', '--user', options[:user] || 'nobody', '--tag', 'Nucleus on Thin']
+  argv_opts << [ '--pid', options[:pid]] if options[:pid]
+  argv_opts << [ '--group', options[:group] || 'nobody' ]
+  argv_opts << [ '--log', File.join(options[:logdir], 'nucleus_daemon.log')] unless ENV['NUCLEUS_API_LOG']
+end
+argv_opts.flatten!
+
+thin = Thin::Runner.new(argv_opts)
+thin.run!

data/bin/nucleus.bat

@@ -0,0 +1 @@
+@ruby -C%~dp0.. "%~dp0nucleus" %*

data/config.ru

@@ -0,0 +1,18 @@
+#########################
+### Setup Application ###
+#########################
+require 'bundler/setup'
+
+# Load configuration
+require 'nucleus/scripts/setup_config'
+# Load application
+require 'nucleus_api/scripts/load_api'
+# Initialize the application
+require 'nucleus_api/scripts/initialize_api'
+
+# Initialize the Rack environment
+# GO TO THIS FILE TO INCLUDE MIDDLEWARE (!)
+require 'nucleus_api/scripts/rack_application'
+
+# finally start the application
+run Nucleus::API::Rack.app

data/config/adapters/cloud_control.yml

@@ -0,0 +1,32 @@
+--- 
+name: "cloudControl"
+id: "cloudcontrol"
+providers:
+  - 
+    name: "cloudControl"
+    id: "cloudcontrol"
+    endpoints:
+      - 
+        name: "cloudControl"
+        id: "cloudcontrol"
+        url: "api.cloudcontrol.com"
+      -
+        name: "dotCloud"
+        id: "dotcloud"
+        url: "api.dotcloudapp.com"
+  -
+    name: "exoscale Apps"
+    id: "exoscale"
+    endpoints:
+      -
+        name: "exoscale Apps"
+        id: "exoscale"
+        url: "api.app.exo.io"
+  -
+    name: "Cloud&Heat App Elevator"
+    id: "cloudandheat"
+    endpoints:
+      -
+        name: "Cloud&Heat App Elevator"
+        id: "cloudandheat"
+        url: "api.cnh-apps.com"

data/config/adapters/cloud_foundry_v2.yml

@@ -0,0 +1,61 @@
+--- 
+name: "Cloud Foundry v2"
+id: "cloud_foundry_v2"
+providers:
+  -
+    name: "bosh"
+    id: "cf-bosh"
+    endpoints:
+      -
+        name: "bosh local"
+        id: "cf-bosh-local"
+        url: "api.10.244.0.34.xip.io"
+        app_domain: "10.244.0.34.xip.io"
+        # trust endpoint, no ssl certificate verification
+        trust: true
+  - 
+    name: "Pivotal"
+    id: "pivotal"
+    endpoints:
+      - 
+        name: "Pivotal Web Services"
+        id: "pivotal"
+        url: "api.run.pivotal.io"
+        app_domain: "cfapps.io"
+  - 
+    name: "IBM Bluemix"
+    id: "bluemix"
+    endpoints:
+      -
+        name: "Europe - Great Britain"
+        id: "bluemix-eu-gb"
+        url: "api.eu-gb.bluemix.net"
+        app_domain: "eu-gb.mybluemix.net"
+      -
+        name: "United States - South"
+        id: "bluemix-us-south"
+        url: "api.ng.bluemix.net"
+        app_domain: "ng.mybluemix.net"
+  -
+    name: "Anynines"
+    id: "anynines"
+    endpoints:
+      -
+        name: "Anynines"
+        id: "anynines"
+        url: "api.de.a9s.eu"
+        app_domain: "a9s.eu"
+  -
+    name: "AppFog"
+    id: "appfog"
+    endpoints:
+      -
+        name: "US East"
+        id: "appfog-us-east"
+        url: "api.useast.appfog.ctl.io"
+        app_domain: "useast.appfog.ctl.io"
+      -
+        name: "US West"
+        id: "appfog-us-west"
+        url: "api.uswest.appfog.ctl.io"
+        app_domain: "uswest.appfog.ctl.io"

data/config/adapters/heroku.yml

@@ -0,0 +1,13 @@
+--- 
+name: "Heroku"
+id: "heroku"
+providers:
+  - 
+    name: "Heroku"
+    id: "heroku"
+    endpoints:
+      - 
+        name: "Heroku"
+        id: "heroku"
+        url: "api.heroku.com"
+        app_domain: "herokuapp.com"

data/config/adapters/openshift_v2.yml

@@ -0,0 +1,20 @@
+--- 
+name: "Openshift v2"
+id: "openshift_v2"
+providers:
+  - 
+    name: "Openshift Online"
+    id: "openshift-online"
+    endpoints:
+      - 
+        name: "Openshift Online"
+        id: "openshift-online"
+        url: "openshift.redhat.com/broker/rest"
+  -
+    name: "Getup Cloud"
+    id: "getup"
+    endpoints:
+      -
+        name: "Getup Cloud"
+        id: "getup"
+        url: "broker.getupcloud.com/broker/rest"

data/config/nucleus_config.rb

@@ -0,0 +1,47 @@
+# [optional] The available levels are: FATAL, ERROR, WARN, INFO, DEBUG
+# Defaults to: Logger::Severity::WARN
+# nucleus_config.logging.level = Logger::Severity::WARN
+
+# [optional] Logging directory
+# Defaults to: File.expand_path(File.join(File.dirname(__FILE__), '..', 'log'))
+# nucleus_config.logging.path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'log'))
+
+# [optional] Database backend to use. Choose one of: [:Daybreak, :LMDB]
+# Defaults to: :Daybreak on Unix, :LMDB on windows systems.
+# nucleus_config.db.backend = :Daybreak
+
+# [optional] Options to start the backend.
+# See http://www.rubydoc.info/gems/moneta/Moneta/Adapters for valid options on the chosen adapter.
+# Defaults to: {}
+# nucleus_config.db.backend_options = {}
+
+# [optional] Please specify the DB directory if you plan to use a file storage.
+# Defaults to: a temporary directory.
+# nucleus_config.db.path = '/Users/cmr/Documents/workspace-rubymine/nucleus/store/'
+
+# [optional] If true, the DB will be deleted when the server is being closed.
+# Defaults to: true
+# nucleus_config.db.delete_on_shutdown = false
+
+# [optional, requires 'nucleus_config.db.path'] If true, the DB will be initialized with default values,
+# which may partially override previously persisted entities.
+# False keeps the changes that were applied during runtime.
+# Defaults to: false
+# nucleus_config.db.override = false
+
+# [optional] Specify the location of a private key (ssh-rsa, OpenSSH) that shall be used for Git actions.
+# E.g. /home/myusername/.ssh/id_rsa
+# If set to false, Nucleus will use its own private key (config/nucleus_git_key.pem) to authenticate all Git actions.
+# Defaults to: nil
+# nucleus_config.ssh.custom_key = nil
+
+# [optional] Specify the public API description
+# nucleus_config.api.title = 'Nucleus - Platform as a Service abstraction layer API'
+# nucleus_config.api.description = 'Nucleus allows to manage multiple PaaS providers with just one API to be used'
+# nucleus_config.api.contact = 'stefan.kolb@uni-bamberg.de'
+# # The name of the license.
+# nucleus_config.api.license = 'TBD'
+# # The URL of the license.
+# nucleus_config.api.license_url = ''
+# # The URL of the API terms and conditions.
+# nucleus_config.api.terms_of_service_url = 'API still under development, no guarantees (!)'

data/lib/nucleus.rb

@@ -0,0 +1,13 @@
+require 'nucleus/version'
+
+# _Nucleus_ is a RESTful abstraction layer to achieve unified deployment and management functions
+# of Platform-as-a-Service (PaaS) providers.<br>
+module Nucleus
+  # Load the default configuration
+  require 'nucleus/scripts/setup_config'
+  # Load the actual application and its dependencies
+  require 'nucleus/scripts/load'
+
+  # now require the parts that are only relevant when using Nucleus as gem
+  require 'nucleus/adapter_resolver'
+end

data/lib/nucleus/adapter_resolver.rb

@@ -0,0 +1,115 @@
+module Nucleus
+  # The {AdapterResolver} can be used within Ruby applications to retrieve a Nucleus adapter.
+  # Returned adapters are patched so that each call enforces authentication and retries a call when a token was expired.
+  class AdapterResolver
+    include Nucleus::UrlConverter
+
+    def initialize(requested_version)
+      fail 'No such version supported' unless Nucleus::VersionDetector.api_versions.include?(requested_version)
+      @api_version = requested_version
+    end
+
+    # Get a list of all adapters that are currently supported.
+    # @return [Hash<String, Hash<String, Nucleus::Adapters::BaseAdapter>>] currently supported adapters
+    def adapters
+      setup
+      @adapters
+    end
+
+    # Load the adapter to interact with the platform of the vendor that is offered at the endpoint_url.
+    # @param [String] vendor The vendor / adapter name that shall be used to communicate with the endpoint.
+    #   Must be supported, otherwise a +StandardError+ will be thrown.
+    # @param [String] username The username that shall be used for authentication
+    # @param [String] password The password that shall be used for authentication
+    # @param [Hash<Symbol,?>] options Further options to apply when creating the adapter instance.
+    #   If available, the default configuration of the vendor configuration is applied as default.
+    # @option options [String] :app_domain The domain where applications of the platform will be made available at.
+    #   This option must be set for custom deployments of platforms like Cloud Foundry or Openshift.
+    #   For IBM Bluemix this value would be: +eu-gb.mybluemix.net+ or +ng.mybluemix.net+, depending on the endpoint.
+    # @option options [String] :check_ssl Set to false if SSL certificates shall not be verified (trust self-signed)
+    # @option options [String] :api_url URL of the endpoint's API that shall be used.
+    #   Must be specified if there are multiple endpoints available and will be forced to https://
+    # @raise [StandardError] if the vendor is unknown / not supported or no unique API endpoint could be identified
+    # @return [Nucleus::Adapters::BaseAdapter] loaded adapter implementation
+    def load(vendor, username, password, options = {})
+      setup
+      fail StandardError, "Could not find adapter for vendor '#{vendor}'" unless @adapters.key?(vendor)
+
+      # load the endpoint's HTTPS enabled API URL
+      endpoint_url = load_endpoint(vendor, options)
+
+      # load default configuration if available
+      if @configurations[vendor].key?(endpoint_url)
+        default_configuration = @configurations[vendor][endpoint_url]
+        options = default_configuration.merge(options)
+      end
+
+      check_ssl = options.key?(:check_ssl) ? options[:check_ssl] : true
+      adapter = @adapters[vendor].new(endpoint_url, options[:app_domain], check_ssl)
+
+      fake_env = { 'HTTP_AUTHORIZATION' => 'Basic ' + ["#{username}:#{password}"].pack('m*').gsub(/\n/, '') }
+      # patch the adapter so that calls are wrapped and expect valid authentication
+      AdapterAuthenticationInductor.patch(adapter, fake_env)
+
+      cache_key = adapter.cache_key(username, password)
+      # no auth object available, perform authentication first
+      auth_object = adapter.auth_client
+      # throws an error if the authentication failed
+      auth_object.authenticate(username, password)
+      # cache the auth object so it does not have to be retrieved per request
+      adapter.cache(cache_key, auth_object)
+
+      # return patched and initially authenticated adapter
+      adapter
+    end
+
+    private
+
+    def load_endpoint(vendor, options)
+      if options.key?(:api_url)
+        # use chosen url endpoint
+        endpoint_url = options[:api_url]
+      elsif @configurations[vendor].length == 1
+        # use default endpoint
+        endpoint_url = @configurations[vendor].keys.first
+      else
+        fail StandardError, "Could not identify an API endpoint for the vendor '#{vendor}'. "\
+          "Please specify the API URL to use with the ':api_url' option."
+      end
+
+      # make sure url uses https
+      secure_url(endpoint_url)
+    end
+
+    def setup
+      # perform the setup only once
+      return if @adapters
+
+      # Initialize the application (import adapters, load DAOs, ...)
+      require 'nucleus/scripts/initialize'
+      # load the configuration values
+      require 'nucleus/scripts/initialize_config_defaults'
+      # Once invoked the configuration is locked
+      require 'nucleus/scripts/finalize'
+
+      @adapters = {}
+      @configurations = {}
+      Nucleus::Adapters.configuration_files.each do |adapter_config|
+        vendor = Nucleus::VendorParser.parse(adapter_config)
+        next unless vendor
+        adapter_clazz = Nucleus::Adapters.adapter_clazz(adapter_config, @api_version)
+        next unless adapter_clazz
+        @adapters[vendor.id] = adapter_clazz
+        @configurations[vendor.id] = {}
+
+        # now load the default configurations for this vendor
+        vendor.providers.each do |provider|
+          provider.endpoints.each do |endpoint|
+            @configurations[vendor.id][secure_url(endpoint.url)] = { check_ssl: !endpoint.trust,
+                                                                     app_domain: endpoint.app_domain }
+          end
+        end
+      end
+    end
+  end
+end