berta 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2c35df5b38eb1ec48f721aab12ab14ae6006f32d
+  data.tar.gz: 205b376e2b57fb9738880bdd47817b4933135f04
+SHA512:
+  metadata.gz: 9500f02e7755d6eab251cb337bf397cb9979f685fc13b736d433756289c3a5da0ba358cd4731f7e58eef955144f93aff8c8598f5e59cceba148a168cb472811a
+  data.tar.gz: 3581efd6664b2f26394e7e0bc752c22c01d7e983ea5d113e026044a3df7d65186e34dc305d992ad5accbe1720f75edd8ae110647b6fa795ffa0c77780b6ba466

data/.rubocop.yml

@@ -0,0 +1,26 @@
+require: rubocop-rspec
+
+AllCops:
+  TargetRubyVersion: 2.0
+
+Metrics/LineLength:
+  Max: 135
+
+Metrics/MethodLength:
+  Max: 15
+
+Metrics/BlockLength:
+  Exclude:
+    - 'Rakefile'
+    - '**/*.rake'
+    - 'spec/**/*.rb'
+    - '*.gemspec'
+Metrics/AbcSize:
+  Exclude:
+    - 'lib/berta/cli.rb'
+
+RSpec/MultipleExpectations:
+  Enabled: false
+
+RSpec/ExampleLength:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,19 @@
+sudo: false
+
+language: ruby
+rvm:
+    - ruby-head
+    - 2.2.0
+
+matrix:
+    allow_failures:
+        - rvm: ruby-head
+fast_finish: true
+
+branches:
+    only:
+        - master
+
+before_install: 'gem install bundler -v 1.13.0'
+
+script: 'bundle exec rake acceptance'

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,14 @@
+
+Copyright 2016 Dusan Baran
+
+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
+
+    http://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.

data/README.md

@@ -0,0 +1,48 @@
+# Berta
+
+[![Build Status](https://travis-ci.org/dudoslav/berta.svg?branch=master)](https://travis-ci.org/dudoslav/berta)
+[![Coverage Status](https://coveralls.io/repos/github/dudoslav/berta/badge.svg?branch=master)](https://coveralls.io/github/dudoslav/berta?branch=master)
+[![Code Climate](https://codeclimate.com/github/dudoslav/berta/badges/gpa.svg)](https://codeclimate.com/github/dudoslav/berta)
+[![Inline docs](http://inch-ci.org/github/dudoslav/berta.svg?branch=master)](http://inch-ci.org/github/dudoslav/berta)
+[![Dependency Status](https://gemnasium.com/badges/github.com/dudoslav/berta.svg)](https://gemnasium.com/github.com/dudoslav/berta)
+
+Berta cleans cloud from unused vms. She sets expiration to all virtual machines
+and when expiration is close she will notify owners. Berta is developed as ruby gem.
+
+## Getting started
+
+### Installation
+
+From rubygems:
+
+```bash
+gem install berta
+```
+
+From source:
+
+```bash
+git clone git://github.com/dudoslav/berta.git
+cd cloudkeeper
+gem install bundler
+bundle install
+```
+
+### Configuration
+
+Config files can be located in:
+* `~/.berta/berta.yml`
+* `/etc/berta/berta.yml`
+* `PATH_TO_GEM_DIR/config/cloudkeeper.yml`
+
+### Execution
+
+Berta needs access to opennebula backend. To do that she needs to know opennebula
+secret and endpoint. This can be specified in config file, as command line options or
+by creating `one_auth` file in `~/.one`.
+To run berta simply type:
+```bash
+berta
+# or if backend and secret are not set
+berta --opennebula-secret=<secret> --opennebula-endpoint=<endpoint>
+```

data/Rakefile

@@ -0,0 +1,17 @@
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+require 'bundler/gem_tasks'
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
+
+task default: :test
+
+desc 'Run acceptance tests (RSpec + Rubocop)'
+task test: 'acceptance'
+
+desc 'Run acceptance tests (RSpec + Rubocop)'
+task :acceptance do |_t|
+  Rake::Task['spec'].invoke
+  Rake::Task['rubocop'].invoke
+end

data/berta.gemspec

@@ -0,0 +1,32 @@
+Gem::Specification.new do |s|
+  s.name = 'berta'
+  s.version = '1.0.0'
+  s.summary = 'Berta VM expiration tool'
+  s.description = 'Berta will check all VMs on OpenNebula cloud for expiration date'
+  s.authors = ['Dusan Baran']
+  s.email = 'dbaran@hotmail.sk'
+  s.homepage = 'https://github.com/dudoslav/berta'
+  s.license = 'Apache License, Version 2.0'
+
+  s.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_development_dependency 'bundler', '~> 1.13'
+  s.add_development_dependency 'rake', '~> 11.2'
+  s.add_development_dependency 'rspec', '~> 3.5'
+  s.add_development_dependency 'rubocop', '~> 0.42'
+  s.add_development_dependency 'rubocop-rspec', '~> 1.7'
+  s.add_development_dependency 'pry', '~> 0.10'
+  s.add_development_dependency 'webmock', '~> 2.3'
+  s.add_development_dependency 'vcr', '~> 3.0'
+  s.add_development_dependency 'coveralls', '~> 0.8'
+
+  s.add_runtime_dependency 'thor', '~> 0.19'
+  s.add_runtime_dependency 'settingslogic', '~> 2.0'
+  s.add_runtime_dependency 'yell', '~> 2.0'
+  s.add_runtime_dependency 'opennebula', '~> 5.2'
+  s.add_runtime_dependency 'chronic_duration', '~> 0.10'
+  s.add_runtime_dependency 'mail', '~> 2.6'
+  s.add_runtime_dependency 'tilt', '~> 2.0'
+end

data/bin/berta

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'berta'
+
+Berta::CLI.start(ARGV)

data/config/berta.yml

@@ -0,0 +1,19 @@
+berta:
+  opennebula:
+    secret:           # Secret for OpenNebula authentication
+    endpoint:         # OpenNebula backend endpoint
+  expiration:         # Action that will be set for execution
+    offset: 10 days   # Time until action will be executed
+    action: terminate-hard # Type of action that will be executed
+  notification:
+    deadline: 1 day   # Time when user should be notified before action will be executed
+  exclude:            # Exclude VMs to ignore them
+    ids:              # VMs with this IDs will be ignored
+    users:            # VMs owned by this users will be ignored
+    groups:           # VMs in this groups will be ignored
+    clusters:         # VMs in this clusters will be ignored
+  logging:
+    file: /var/log/berta/berta.log # File ro write log to. To turn off file logging leave this field empty
+    level: error # Logging level
+  dry-run: false # Berta wont change anything on running instance of OpenNebula
+  debug: false # Debug mode

data/config/email.erb

@@ -0,0 +1,18 @@
+<%# Avaliable parametes: %>
+<%# [String] user_name   %>
+<%# [String] user_email  %>
+<%# [Array<Hash>] vms, Array of Hashes with values: %>
+<%# 	[String] id  %>
+<%# 	[String] name  %>
+<%# 	[String] expiration  %>
+From: cesnet@mail.muni.cz
+To: <%= user_email %>
+Subject: OpenNebula VM expiration
+
+Hi <%= user_name %>,
+your vms are about to expire..
+
+VM Name | Expiration Date
+<% vms.each do |vm| %>
+	<%= vm[:name] %> | <%= Time.at(vm[:expiration]) %>
+<% end %>

data/lib/berta.rb

@@ -0,0 +1,13 @@
+# Main Berta module
+module Berta
+  autoload :Service, 'berta/service'
+  autoload :VirtualMachineHandler, 'berta/virtual_machine_handler'
+  autoload :ExpirationManager, 'berta/expiration_manager'
+  autoload :NotificationManager, 'berta/notification_manager'
+  autoload :CommandExecutor, 'berta/command_executor'
+  autoload :CLI, 'berta/cli'
+  autoload :Errors, 'berta/errors'
+  autoload :Entities, 'berta/entities'
+  autoload :Utils, 'berta/utils'
+  autoload :Settings, 'berta/settings'
+end

data/lib/berta/cli.rb

@@ -0,0 +1,108 @@
+require 'thor'
+require 'yell'
+
+module Berta
+  # CLI for berta
+  class CLI < Thor
+    def self.safe_fetch(keys)
+      current = Berta::Settings
+      keys.each do |key|
+        current = current[key]
+        break unless current
+      end
+      current
+    end
+
+    class_option :'opennebula-secret',
+                 default: safe_fetch(%w(opennebula secret)),
+                 type: :string
+    class_option :'opennebula-endpoint',
+                 default: safe_fetch(%w(opennebula endpoint)),
+                 type: :string
+    class_option :'expiration-offset',
+                 required: true,
+                 default: safe_fetch(%w(expiration offset)),
+                 type: :string
+    class_option :'expiration-action',
+                 required: true,
+                 default: safe_fetch(%w(expiration action)),
+                 type: :string
+    class_option :'notification-deadline',
+                 required: true,
+                 default: safe_fetch(%w(notification deadline)),
+                 type: :string
+    class_option :'exclude-ids',
+                 default: safe_fetch(%w(exclude ids)),
+                 type: :array
+    class_option :'exclude-users',
+                 default: safe_fetch(%w(exclude users)),
+                 type: :array
+    class_option :'exclude-groups',
+                 default: safe_fetch(%w(exclude groups)),
+                 type: :array
+    class_option :'exclude-clusters',
+                 default: safe_fetch(%w(exclude clusters)),
+                 type: :array
+    class_option :'dry-run',
+                 default: safe_fetch(%w(dry-run)),
+                 type: :boolean
+    class_option :'logging-file',
+                 default: safe_fetch(%w(logging file)),
+                 type: :string
+    class_option :'logging-level',
+                 required: true,
+                 default: safe_fetch(%w(logging level)),
+                 type: :string
+    class_option :debug,
+                 default: safe_fetch(%w(debug)),
+                 type: :boolean
+
+    desc 'cleanup', 'Task that sets all expiration to all vms and notifies users'
+    def cleanup
+      initialize_configuration(options)
+      initialize_logger(options)
+      Berta::CommandExecutor.cleanup
+    end
+    default_task :cleanup
+
+    private
+
+    def initialize_configuration(options)
+      settings = Hash.new { |hash, key| hash[key] = {} }
+      settings['opennebula']['secret'] = options['opennebula-secret']
+      settings['opennebula']['endpoint'] = options['opennebula-endpoint']
+      settings['expiration']['offset'] = options['expiration-offset']
+      settings['expiration']['action'] = options['expiration-action']
+      settings['notification']['deadline'] = options['notification-deadline']
+      settings['exclude']['ids'] = options['exclude-ids']
+      settings['exclude']['users'] = options['exclude-users']
+      settings['exclude']['groups'] = options['exclude-groups']
+      settings['exclude']['clusters'] = options['exclude-clusters']
+      settings['dry-run'] = options['dry-run']
+      settings['debug'] = options['debug']
+      settings['logging']['file'] = options['logging-file']
+      settings['logging']['level'] = options['logging-level']
+      Berta::Settings.merge!(settings)
+    end
+
+    def initialize_logger(options)
+      logging_level = options['logging-level']
+      logging_level = 'debug' if options['debug'] || options['dry-run']
+
+      Yell.new :stdout, name: Object, level: logging_level, format: Yell::DefaultFormat
+      Object.send :include, Yell::Loggable
+
+      setup_file_logger(options['logging-file']) if options['logging-file']
+
+      logger.debug 'Running in debug mode...'
+    end
+
+    def setup_file_logger(logging_file)
+      unless (File.exist?(logging_file) && File.writable?(logging_file)) || File.writable?(File.dirname(logging_file))
+        logger.error "File #{logging_file} isn't writable"
+        return
+      end
+      logger.adapter :file, logging_file
+    end
+  end
+end

data/lib/berta/command_executor.rb

@@ -0,0 +1,18 @@
+module Berta
+  # Class for executing main berta commands
+  class CommandExecutor
+    # Function that performs clean up operation.
+    # Connects to opennebula database,
+    # runs expiration update process and
+    # notifies users about upcoming expirations.
+    def self.cleanup
+      service = Berta::Service.new(Berta::Settings['opennebula']['secret'],
+                                   Berta::Settings['opennebula']['endpoint'])
+      vms = service.running_vms
+      Berta::ExpirationManager.new.update_expirations(vms)
+      Berta::NotificationManager.new(service).notify_users(vms)
+    rescue Berta::Errors::BackendError => e
+      logger.error e.message
+    end
+  end
+end

data/lib/berta/entities.rb

@@ -0,0 +1,6 @@
+module Berta
+  # Module for entity classes
+  module Entities
+    autoload :Expiration, 'berta/entities/expiration.rb'
+  end
+end

data/lib/berta/entities/expiration.rb

@@ -0,0 +1,82 @@
+module Berta
+  module Entities
+    # Class for storing expiration data, also can be created from xml
+    class Expiration
+      attr_reader :id, :time, :action
+
+      # Creates Expiration class instance from XMLElement.
+      #
+      # @param xml [XMLElement] XML from which to create instance
+      # @return [Berta::Entities::Expiration] Expiration from given xml
+      # @raise [Berta::Errors::Entities::InvalidEntityXMLError] If XMLElement was not in correct format
+      def self.from_xml(xml)
+        check_xml!(xml)
+        Berta::Entities::Expiration.new(xml['ID'], xml['TIME'], xml['ACTION'])
+      end
+
+      # Raises error if XML element is not in correct format.
+      #
+      # @param xml [XMLElement] XML to check for all required values
+      # @raise [Berta::Errors::Entities::InvalidEntityXMLError] If xml is not in correct format
+      def self.check_xml!(xml)
+        raise Berta::Errors::Entities::InvalidEntityXMLError, 'wrong enxpiration xml recieved' \
+          unless %w(ID
+                    ACTION
+                    TIME).all? { |path| xml.has_elements? path }
+      end
+
+      # Creates expiration class instance from given arguments.
+      #
+      # @param id [String] Schelude action id
+      # @param time [String] Schelude action execution time
+      # @param action [String] Schelude action
+      def initialize(id, time, action)
+        @id = id
+        @time = time
+        @action = action
+      end
+
+      # Generate schelude action template that can be used
+      # in VMS USER_TEMPLATE/SCHED_ACTION
+      #
+      # @return [String] Schelude action template
+      def template
+        <<-EOT
+      SCHED_ACTION = [
+          ID     = "#{id}",
+          ACTION = "#{action}",
+          TIME   = "#{time}"
+      ]
+      EOT
+      end
+
+      # Determines if this schelude action is in notification interval.
+      # That means its expiration is closer to Time.now than notification
+      # deadline.
+      #
+      # @return [Boolean] Truthy if in notification interval else falsy
+      def in_notification_interval?
+        time_interval = time.to_i - Time.now.to_i
+        time_interval <= Berta::Settings.notification_deadline && time_interval >= 0
+      end
+
+      # Determines if this schelude action is in expiration interval.
+      # That means its expiration is closer to Time.now that expiration
+      # offset.
+      #
+      # @return [Boolean] Truthy if in expiration interval else falsy
+      def in_expiration_interval?
+        time_interval = time.to_i - Time.now.to_i
+        time_interval <= Berta::Settings.expiration_offset && time_interval >= 0
+      end
+
+      # Determines if this expiration has default expiration action set.
+      # Default expiration action is action defined in settings file.
+      #
+      # @return [Boolean] Truthy if has default action else falsy
+      def default_action?
+        action == Berta::Settings.expiration.action
+      end
+    end
+  end
+end