foreman_opennebula 2.3.0

data/app/models/foreman_opennebula/opennebula.rb

@@ -0,0 +1,221 @@
+module ForemanOpennebula
+  class Opennebula < ComputeResource
+    include ForemanOpennebula::KeyPairComputeResource
+
+    validates :url, :format => { :with => URI::DEFAULT_PARSER.make_regexp }, :presence => true
+    validates :user, :password, :presence => true
+
+    delegate :flavors, :networks, :to => :client
+
+    def self.provider_friendly_name
+      'OpenNebula'
+    end
+
+    def self.model_name
+      ComputeResource.model_name
+    end
+
+    def capabilities
+      [:build, :image, :key_pair]
+    end
+
+    def provided_attributes
+      super.merge({ :mac => :mac })
+    end
+
+    def possible_scheduler_hints
+      %w[Cluster Host Raw]
+    end
+
+    def available_flavors
+      # TODO: Sort by name.
+      flavors.sort_by { |flavor| flavor.id.to_i }
+    end
+
+    def available_networks
+      networks.sort_by(&:name)
+    end
+
+    def available_images
+      image_pool = ::OpenNebula::ImagePool.new(client.client)
+      rc = image_pool.info
+      raise ::Foreman::Exception.new N_(rc.message) if ::OpenNebula.is_error?(rc)
+      image_pool.sort_by(&:name)
+    end
+
+    def available_clusters
+      cluster_pool = ::OpenNebula::ClusterPool.new(client.client)
+      rc = cluster_pool.info
+      raise ::Foreman::Exception.new N_(rc.message) if ::OpenNebula.is_error?(rc)
+      cluster_pool.sort_by(&:name)
+    end
+
+    def available_hosts
+      host_pool = ::OpenNebula::HostPool.new(client.client)
+      rc = host_pool.info
+      raise ::Foreman::Exception.new N_(rc.message) if ::OpenNebula.is_error?(rc)
+      host_pool.sort_by(&:name)
+    end
+
+    def available_vmgroups
+      vmgroup_pool = ::OpenNebula::VMGroupPool.new(client.client)
+      rc = vmgroup_pool.info
+      raise ::Foreman::Exception.new N_(rc.message) if ::OpenNebula.is_error?(rc)
+      vmgroup_pool.sort_by(&:name)
+    end
+
+    def available_roles(vmgroup_id)
+      available_vmgroups.detect { |vmgroup| vmgroup.id == vmgroup_id.to_i }.role_names.sort
+    end
+
+    def available_users
+      user_pool = ::OpenNebula::UserPool.new(client.client)
+      rc = user_pool.info
+      raise ::Foreman::Exception.new N_(rc.message) if ::OpenNebula.is_error?(rc)
+      user_pool
+    end
+
+    def create_vm(args = {})
+      vm_attrs = {:name => args[:name]}
+      vm_attrs[:flavor] = flavors.get(args[:template_id])
+      vm_attrs[:flavor].template_id = args[:template_id]
+      vm_attrs[:flavor].cpu = args[:cpu] if args[:cpu].present?
+      vm_attrs[:flavor].vcpu = args[:vcpu] if args[:vcpu].present?
+      vm_attrs[:flavor].memory = args[:memory] if args[:memory].present?
+
+      if args[:disk_size].present?
+        [vm_attrs[:flavor].disk].flatten.compact.first[:SIZE] = args[:disk_size]
+      end
+
+      vm_attrs[:flavor].nic = args[:interfaces_attributes].map do |_, attrs|
+        nic = {
+          :vnet => networks.get(attrs[:vnet])
+        }
+        nic[:ip] = attrs['ip'] if args['provision_method'] == 'image' && attrs['ip'].present?
+        if vm_attrs[:flavor].nic_default.present?
+          vm_attrs[:flavor].nic_default.each do |param, value|
+            nic[param.downcase.to_sym] = value
+          end
+        end
+        new_interface(nic)
+      end
+
+      if args[:scheduler_hint_filter].present? && args[:scheduler_hint_data].present?
+        if args[:scheduler_hint_filter] == 'Cluster'
+          cluster = available_clusters.detect { |c| c.id == args[:scheduler_hint_data].to_i }
+          vm_attrs[:flavor].sched_requirements = "CLUSTER_ID = #{cluster.id}"
+        elsif args[:scheduler_hint_filter] == 'Host'
+          host = available_hosts.detect { |h| h.id == args[:scheduler_hint_data].to_i }
+          vm_attrs[:flavor].sched_requirements = "ID = #{host.id}"
+        else
+          vm_attrs[:flavor].sched_requirements = args[:scheduler_hint_data]
+        end
+      end
+
+      if args[:vmgroup_id].present? && args[:vmgroup_role].present?
+        vm_attrs[:flavor].vmgroup = { 'VMGROUP_ID' => args[:vmgroup_id], 'ROLE' => args[:vmgroup_role] }
+      end
+
+      if args['provision_method'] == 'image' && args['image_id'].present?
+        [vm_attrs[:flavor].disk].flatten.compact.first.delete('IMAGE')
+        [vm_attrs[:flavor].disk].flatten.compact.first['IMAGE_ID'] = args[:image_id]
+
+        vm_attrs[:flavor].context['SET_HOSTNAME'] = args[:name]
+        vm_attrs[:flavor].context['USER_DATA'] = args[:user_data] if args[:user_data].present?
+
+        vm_attrs[:flavor].os['BOOT'] = 'disk0'
+      else
+        vm_attrs[:flavor].os['BOOT'] = 'nic0,disk0'
+      end
+
+      vm = super(vm_attrs)
+      vm.wait_for { vm.status == 1 }
+      find_vm_by_uuid(vm.id)
+    end
+
+    def vm_ready(vm)
+      vm.wait_for { ready? || poweroff? }
+      raise Foreman::Exception.new(N_('Failed to run VM %{name}'), { :name => vm.name }) if vm.poweroff?
+    end
+
+    def supports_update?
+      true
+    end
+
+    def update_required?(old_attrs, new_attrs)
+      vm = find_vm_by_uuid(old_attrs[:uuid])
+      old_attrs[:disk_size] = vm.disk_size
+      super(old_attrs, new_attrs)
+    end
+
+    def save_vm(uuid, attr)
+      vm = find_vm_by_uuid(uuid)
+      changed_attrs = %i[cpu vcpu memory].reject { |k| vm.send(k).to_s == attr[k].to_s }
+
+      if !vm.ready? && !vm.poweroff?
+        raise ::Foreman::Exception.new N_("The VM status: #{vm.status}. It should be ACTIVE (3) or POWEROFF (8)")
+      end
+
+      last_state = vm.state
+      if vm.ready?
+        vm.onevm_object.poweroff(true)
+        vm.wait_for { poweroff? }
+      end
+
+      if changed_attrs.any?
+        flavor = client.flavors.new
+        %i[cpu vcpu memory].each { |k| flavor.send("#{k}=", attr[k].to_s) }
+        vm.onevm_object.resize(flavor.to_s, true)
+
+        renewed_vm = find_vm_by_uuid(uuid)
+        unchanged_attrs = changed_attrs.reject { |k| renewed_vm.send(k).to_s == attr[k].to_s }
+        if unchanged_attrs.any?
+          raise ::Foreman::Exception.new N_("Parameter #{unchanged_attrs.join(', ')} was not changed. "\
+                                            'Check if the host has enough resources for this VM')
+        end
+      end
+
+      if vm.disk_size.to_i != attr[:disk_size].to_i
+        disk_id = vm.disks.first.disk_id.to_i
+        rc = vm.onevm_object.disk_resize(disk_id, attr[:disk_size].to_i)
+        raise ::Foreman::Exception.new N_(rc.message) if ::OpenNebula.is_error?(rc)
+        sleep(1) # wait before resume vm
+      end
+
+      if last_state == 'RUNNING'
+        vm.onevm_object.resume
+        sleep(2)
+        vm_ready(vm)
+      end
+      vm
+    end
+
+    def test_connection(options = {})
+      super
+      %i[url user password].all? { |i| errors[i].empty? } && !client.client.get_version.is_a?(OpenNebula::Error)
+    rescue => e
+      errors[:base] << e.message
+    end
+
+    def console(uuid)
+      vm = find_vm_by_uuid(uuid)
+      WsProxy.start(:host => vm.host, :host_port => vm.display[:port],
+        :password => vm.display[:password]).merge(:type => vm.display[:type], :name => vm.name)
+    end
+
+    def associated_host(vm)
+      associate_by('mac', vm.interfaces.map(&:mac))
+    end
+
+    private
+
+    def client
+      @client ||= Fog::Compute.new(
+        provider: 'OpenNebula',
+        opennebula_username: user,
+        opennebula_password: password,
+        opennebula_endpoint: url
+      )
+    end
+  end
+end

data/app/views/api/v2/compute_resources/opennebula.json.rabl

@@ -0,0 +1 @@
+attributes :url

data/app/views/compute_resources/form/_opennebula.html.erb

@@ -0,0 +1,6 @@
+<%= text_f f, :url, :label => _("URL"), :size => "col-md-8", :help_block => _("e.g. http://host.example.com:2633/RPC2") %>
+<%= text_f f, :user, :label => _("User") %>
+<%= password_f f, :password, :label => _("Password"), :unset => unset_password? %>
+<div class="col-md-offset-2">
+  <%= test_connection_button_f(f, (f.object.flavors rescue false)) %>
+</div>

data/app/views/compute_resources/show/_opennebula.html.erb

@@ -0,0 +1,4 @@
+<tr>
+  <td><%= _("URL") %></td>
+  <td><%= @compute_resource.url %></td>
+</tr>

data/app/views/compute_resources_vms/form/opennebula/_base.html.erb

@@ -0,0 +1,85 @@
+<% unless new_vm %>
+  <% if host.compute_object.ready? %>
+    <%= alert(:header => _('Warning'),
+              :class  => 'alert-warning',
+              :text   => _('Editing VM parameters causes it to reboot.')) %>
+  <% end %>
+  <%= alert(:header => _('Notice'),
+            :class  => 'alert-info',
+            :text   => _('Disk size can only be increased.')) %>
+  <% disabled = true %>
+<% else %>
+  <% disabled = false %>
+<% end %>
+
+<%= select_f f, :template_id, compute_resource.available_flavors, :id, :name, {},
+      :label    => _('Template'),
+      :disabled => disabled %>
+
+<%= counter_f f, :cpu,
+      :label       => _('CPU'),
+      :min         => 0.01,
+      :help_inline => _('Default from template') %>
+
+<%= counter_f f, :vcpu,
+      :label       => _('VCPU'),
+      :min         => 1,
+      :help_inline => _('Default from template') %>
+
+<%= megabyte_size_f f, :memory,
+      :label       => _('Memory'),
+      :help_inline => _('Default from template') %>
+
+<%= megabyte_size_f f, :disk_size,
+      :label       => _('Disk'),
+      :help_inline => _('Default from template') %>
+
+<% unless controller_name == 'compute_attributes' %>
+  <%= select_f f, :vmgroup_id, compute_resource.available_vmgroups, :id, :name, { :include_blank => true },
+        :label       => _('VM Group'),
+        :help_inline => _('Optional'),
+        :'data-url'  => url_for(controller: 'foreman_opennebula/hosts', action: 'vmgroup_selected'),
+        :onchange    => 'vmgroupSelected(this);',
+        :disabled    => disabled %>
+
+  <div id='vmgroup_role_wrapper'>
+  <% if host.compute_object.vmgroup_id.present? %>
+    <%= render :partial => 'compute_resources_vms/form/opennebula/vmgroup_role', :locals => {
+          :vmgroup_id => host.compute_object.vmgroup_id,
+          :disabled   => disabled
+        } %>
+  <% end %>
+  </div>
+
+  <%= selectable_f f, :scheduler_hint_filter, compute_resource.possible_scheduler_hints, { :include_blank => true },
+        :label                             => _('Scheduler hint filter'),
+        :'data-url'                        => url_for(controller: 'foreman_opennebula/hosts',
+                                                      action: 'scheduler_hint_filter_selected'),
+        :'data-minimum-results-for-search' => 'Infinity',
+        :onchange                          => 'schedulerHintFilterSelected(this);',
+        :help_inline                       => _('Optional'),
+        :disabled                          => disabled %>
+
+  <div id='scheduler_hint_data_wrapper'>
+  <% if host.compute_object.scheduler_hint_filter.present? %>
+    <%= render :partial => 'compute_resources_vms/form/opennebula/scheduler_hint_data', :locals => {
+          :scheduler_hint_filter => host.compute_object.scheduler_hint_filter,
+          :disabled              => disabled
+        } %>
+  <% end %>
+  </div>
+
+  <%-
+      arch ||= nil ; os ||= nil
+      images = possible_images(compute_resource, arch, os)
+  -%>
+  <div id='image_selection'>
+    <%= select_f f, :image_id, images, :uuid, :name, {
+          :include_blank => (images.empty? || images.size == 1) ? false : _('Please select an image') },
+          :disabled      => images.empty? || (params[:host] && params[:host][:provision_method] == 'build'),
+          :label         => _('Image') %>
+  </div>
+
+  <%= javascript_include_tag 'foreman_opennebula/vmgroup_selected' %>
+  <%= javascript_include_tag 'foreman_opennebula/scheduler_hint_filter_selected' %>
+<% end %>

data/app/views/compute_resources_vms/form/opennebula/_network.html.erb

@@ -0,0 +1,2 @@
+<%= select_f f, :vnet, compute_resource.available_networks, :id, :name, { :include_blank => true },
+  { :label => _('Network'), :label_size => "col-md-3", :size => "col-md-8" } %>

data/app/views/compute_resources_vms/form/opennebula/_scheduler_hint_data.html.erb

@@ -0,0 +1,13 @@
+<%- scheduler_hint_filter ||= @host.compute_attributes[:scheduler_hint_filter] %>
+<%- disabled ||= false %>
+<%= fields_for "#{type}[compute_attributes]", @host.compute_object do |f| %>
+  <%- if scheduler_hint_filter == 'Cluster' %>
+    <%= select_f f, :scheduler_hint_data, @host.compute_resource.available_clusters, :id, :name,
+          { :include_blank => true }, :label => _("Deploy to cluster"), :disabled => disabled %>
+  <%- elsif scheduler_hint_filter == 'Host' %>
+    <%= select_f f, :scheduler_hint_data, @host.compute_resource.available_hosts, :id, :name,
+          { :include_blank => true }, :label => _("Deploy to host"), :disabled => disabled %>
+  <%- else %>
+    <%= text_f f, :scheduler_hint_data, :label => _("Scheduler hint data"), :disabled => disabled %>
+  <%- end %>
+<%- end %>

data/app/views/compute_resources_vms/form/opennebula/_vmgroup_role.html.erb

@@ -0,0 +1,6 @@
+<%- vmgroup_id ||= @host.compute_attributes[:vmgroup_id] %>
+<%- disabled ||= false %>
+<%= fields_for "#{type}[compute_attributes]", @host.compute_object do |f| %>
+  <%= selectable_f f, :vmgroup_role, @host.compute_resource.available_roles(vmgroup_id),
+        { :include_blank => true }, :label => _("Role"), :disabled => disabled %>
+<%- end %>

data/app/views/compute_resources_vms/index/_opennebula.html.erb

@@ -0,0 +1,26 @@
+<thead>
+  <tr>
+    <th><%= _('Name') %></th>
+    <th><%= _('CPU') %></th>
+    <th><%= _('VCPU') %></th>
+    <th><%= _('Memory') %></th>
+    <th><%= _('Storage') %></th>
+    <th><%= _('Host') %></th>
+    <th><%= _('State') %></th>
+    <th><%= _('Actions') %></th>
+  </tr>
+</thead>
+<tbody>
+  <% @vms.each do |vm| %>
+    <tr>
+      <td><%= link_to_if_authorized vm.name, hash_for_compute_resource_vm_path(:compute_resource_id => @compute_resource, :id => vm.uuid).merge(:auth_object => @compute_resource, :auth_action => 'view', :authorizer => authorizer) %></td>
+      <td><%= vm.cpu %></td>
+      <td><%= vm.vcpu %></td>
+      <td><%= number_to_human_size(vm.memory.to_i.megabytes) %></td>
+      <td><%= number_to_human_size(vm.disks.map { |disk| disk.size.to_i.megabytes }.sum) %></td>
+      <td><%= vm.host %></td>
+      <td><span <%= vm_power_class(vm.ready?) %>><%= vm_state(vm) %></span></td>
+      <td><%= action_buttons(*available_actions(vm)) %></td>
+    </tr>
+  <% end %>
+</tbody>

data/app/views/compute_resources_vms/show/_opennebula.html.erb

@@ -0,0 +1,47 @@
+<% title @vm.name %>
+<div class='col-md-12'>
+  <table class="<%= table_css_classes %>">
+    <thead>
+      <tr><th colspan="2"><%= _('Properties') %></th></tr>
+    </thead>
+    <tbody>
+      <%= prop :cpu, 'CPU' %>
+      <%= prop :vcpu, 'VCPU' %>
+      <tr>
+        <td><%= _('Memory') %></td>
+        <td><%= number_to_human_size(@vm.memory.to_i.megabytes) %></td>
+      </tr>
+      <% @vm.disks.each do |disk| %>
+      <tr>
+        <td><%= _("Disk %s") % disk.target %></td>
+        <td><%= "#{disk.image} / #{number_to_human_size(disk.size.to_i.megabytes)}" %></td>
+      </tr>
+      <% end %>
+      <% @vm.interfaces.each do |iface| %>
+      <tr>
+        <td><%= _("Nic %s") % iface.nic_id %></td>
+        <td><%= "#{iface.network} / #{iface.mac}" %></td>
+      </tr>
+      <% end %>
+      <% if @vm.vmgroup_id.present? %>
+      <tr>
+        <td><%= _("VM Group") %></td>
+        <td><%= @compute_resource.available_vmgroups.detect { |vmgroup| vmgroup.id == @vm.vmgroup_id.to_i }.name %></td>
+      </tr>
+      <tr>
+        <td><%= _("Role") %></td>
+        <td><%= @vm.vmgroup_role %></td>
+      </tr>
+      <% end %>
+      <% if @vm.host.present? %>
+      <tr>
+        <td><%= _("Cluster") %></td>
+        <td><%= @compute_resource.available_hosts.detect { |host| host.name == @vm.host }.to_hash['HOST']['CLUSTER'] %></td>
+      </tr>
+      <%= prop :host %>
+      <% end %>
+      <%= prop :state, 'LCM State' %>
+      <%= prop :sched_message if @vm.sched_message %>
+    </tbody>
+  </table>
+</div>

data/app/views/images/form/_opennebula.html.erb

@@ -0,0 +1,4 @@
+<%= image_field f, :label => _("Image"), :help_inline => _("Image used to create new vm.") %>
+<%= text_f f, :username, :value => @image.username || "root", :help_inline => _("The user that is used to ssh into the instance, normally cloud-user, ec2-user, ubuntu, root etc") %>
+<%= password_f f, :password, :help_inline => _("Password to authenticate with - used for SSH finish step.") %>
+<%= checkbox_f f, :user_data, :help_inline => _("Does this image support user data input (e.g. via cloud-init)?") %>

data/config/routes.rb

@@ -0,0 +1,6 @@
+Rails.application.routes.draw do
+  namespace :foreman_opennebula do
+    match 'hosts/vmgroup_selected', :to => 'hosts#vmgroup_selected', :via => 'post'
+    match 'hosts/scheduler_hint_filter_selected', :to => 'hosts#scheduler_hint_filter_selected', :via => 'post'
+  end
+end

data/lib/foreman_opennebula/engine.rb

@@ -0,0 +1,59 @@
+require 'fast_gettext'
+require 'gettext_i18n_rails'
+require 'fog/opennebula'
+
+module ForemanOpennebula
+  class Engine < ::Rails::Engine
+    isolate_namespace ForemanOpennebula
+    engine_name 'foreman_opennebula'
+
+    initializer 'foreman_opennebula.register_gettext', after: :load_config_initializers do |_app|
+      locale_dir = File.join(File.expand_path('../..', __dir__), 'locale')
+      locale_domain = 'foreman_opennebula'
+      Foreman::Gettext::Support.add_text_domain locale_domain, locale_dir
+    end
+
+    initializer 'foreman_opennebula.register_plugin', :before => :finisher_hook do |_app|
+      Foreman::Plugin.register :foreman_opennebula do
+        requires_foreman '>= 3.7'
+        compute_resource ForemanOpennebula::Opennebula
+        register_global_js_file 'global'
+      end
+    end
+
+    config.to_prepare do
+      require 'fog/opennebula/models/compute/server'
+      require 'fog/opennebula/models/compute/flavor'
+      require 'fog/opennebula/models/compute/interface'
+      require File.expand_path('../../app/models/concerns/fog_extensions/opennebula/server', __dir__)
+      require File.expand_path('../../app/models/concerns/fog_extensions/opennebula/flavor', __dir__)
+      require File.expand_path('../../app/models/concerns/fog_extensions/opennebula/interface', __dir__)
+      require File.expand_path('../../app/helpers/concerns/foreman_opennebula/hosts_helper_extensions', __dir__)
+      require File.expand_path('../../app/helpers/concerns/foreman_opennebula/form_helper_extensions', __dir__)
+
+      ::Fog::Compute::OpenNebula::Server.include(FogExtensions::OpenNebula::Server)
+      ::Fog::Compute::OpenNebula::Flavor.include(FogExtensions::OpenNebula::Flavor)
+      ::Fog::Compute::OpenNebula::Interface.include(FogExtensions::OpenNebula::Interface)
+      ::HostsHelper.include(ForemanOpennebula::HostsHelperExtensions)
+      # ::FormHelper.include(ForemanOpennebula::FormHelperExtensions)
+      ::ActionView::Base.include(ForemanOpennebula::FormHelperExtensions)
+    rescue => e
+      Rails.logger.warn "ForemanOpennebula: skipping engine hook (#{e})"
+    end
+
+    assets_to_precompile =
+      Dir.chdir(root) do
+        Dir['app/assets/javascripts/**/*', 'app/assets/stylesheets/**/*'].map do |f|
+          f.split(File::SEPARATOR, 4).last
+        end
+      end
+
+    initializer 'foreman_opennebula.assets.precompile' do |app|
+      app.config.assets.precompile += assets_to_precompile
+    end
+
+    initializer 'foreman_opennebula.configure_assets', group: :assets do
+      SETTINGS[:foreman_opennebula] = { assets: { precompile: assets_to_precompile } }
+    end
+  end
+end

data/lib/foreman_opennebula/version.rb

@@ -0,0 +1,3 @@
+module ForemanOpennebula
+  VERSION = '2.3.0'.freeze
+end

data/lib/foreman_opennebula.rb

@@ -0,0 +1,4 @@
+require 'foreman_opennebula/engine'
+
+module ForemanOpennebula
+end

data/lib/tasks/foreman_opennebula_tasks.rake

@@ -0,0 +1,48 @@
+require 'rake/testtask'
+
+# Tasks
+namespace :foreman_opennebula do
+  namespace :example do
+    desc 'Example Task'
+    task task: :environment do
+      # Task goes here
+    end
+  end
+end
+
+# Tests
+namespace :test do
+  desc 'Test ForemanOpennebula'
+  Rake::TestTask.new(:foreman_opennebula) do |t|
+    test_dir = File.expand_path('../../test', __dir__)
+    t.libs << 'test'
+    t.libs << test_dir
+    t.pattern = "#{test_dir}/**/*_test.rb"
+    t.verbose = true
+    t.warning = false
+  end
+end
+
+namespace :foreman_opennebula do
+  task :rubocop do
+    begin
+      require 'rubocop/rake_task'
+      RuboCop::RakeTask.new(:rubocop_foreman_opennebula) do |task|
+        task.patterns = ["#{ForemanOpennebula::Engine.root}/app/**/*.rb",
+                         "#{ForemanOpennebula::Engine.root}/lib/**/*.rb",
+                         "#{ForemanOpennebula::Engine.root}/test/**/*.rb"]
+      end
+    rescue
+      puts 'Rubocop not loaded.'
+    end
+
+    Rake::Task['rubocop_foreman_opennebula'].invoke
+  end
+end
+
+Rake::Task[:test].enhance ['test:foreman_opennebula']
+
+load 'tasks/jenkins.rake'
+if Rake::Task.task_defined?(:'jenkins:unit')
+  Rake::Task['jenkins:unit'].enhance ['test:foreman_opennebula', 'foreman_opennebula:rubocop']
+end

data/locale/Makefile

@@ -0,0 +1,60 @@
+#
+# Makefile for PO merging and MO generation. More info in the README.
+#
+# make all-mo (default) - generate MO files
+# make check - check translations using translate-tool
+# make tx-update - download and merge translations from Transifex
+# make clean - clean everything
+#
+DOMAIN = foreman_opennebula
+VERSION = $(shell ruby -e 'require "rubygems";spec = Gem::Specification::load(Dir.glob("../*.gemspec")[0]);puts spec.version')
+POTFILE = $(DOMAIN).pot
+MOFILE = $(DOMAIN).mo
+POFILES = $(shell find . -name '$(DOMAIN).po')
+MOFILES = $(patsubst %.po,%.mo,$(POFILES))
+POXFILES = $(patsubst %.po,%.pox,$(POFILES))
+EDITFILES = $(patsubst %.po,%.edit.po,$(POFILES))
+
+%.mo: %.po
+	mkdir -p $(shell dirname $@)/LC_MESSAGES
+	msgfmt -o $(shell dirname $@)/LC_MESSAGES/$(MOFILE) $<
+
+# Generate MO files from PO files
+all-mo: $(MOFILES)
+
+# Check for malformed strings
+%.pox: %.po
+	msgfmt -c $<
+	pofilter --nofuzzy -t variables -t blank -t urls -t emails -t long -t newlines \
+		-t endwhitespace -t endpunc -t puncspacing -t options -t printf -t validchars --gnome $< > $@
+	cat $@
+	! grep -q msgid $@
+
+%.edit.po:
+	touch $@
+
+check: $(POXFILES)
+
+# Unify duplicate translations
+uniq-po:
+	for f in $(shell find ./ -name "*.po") ; do \
+		msguniq $$f -o $$f ; \
+	done
+
+tx-pull: $(EDITFILES)
+	tx pull -f
+	for f in $(EDITFILES) ; do \
+		sed -i 's/^\("Project-Id-Version: \).*$$/\1$(DOMAIN) $(VERSION)\\n"/' $$f; \
+	done
+
+tx-update: tx-pull
+	@echo
+	@echo Run rake plugin:gettext[$(DOMAIN)] from the Foreman installation, then make -C locale mo-files to finish
+	@echo
+
+mo-files: $(MOFILES)
+	git add $(POFILES) $(POTFILE) ../locale/*/LC_MESSAGES
+	git commit -m "i18n - pulling from tx"
+	@echo
+	@echo Changes commited!
+	@echo

data/locale/en/foreman_opennebula.po

@@ -0,0 +1,19 @@
+# foreman_opennebula
+#
+# This file is distributed under the same license as foreman_opennebula.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: version 0.0.1\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2014-08-20 08:46+0100\n"
+"PO-Revision-Date: 2014-08-20 08:54+0100\n"
+"Last-Translator: Foreman Team <foreman-dev@googlegroups.com>\n"
+"Language-Team: Foreman Team <foreman-dev@googlegroups.com>\n"
+"Language: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+

data/locale/foreman_opennebula.pot

@@ -0,0 +1,19 @@
+# foreman_opennebula
+#
+# This file is distributed under the same license as foreman_opennebula.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: version 0.0.1\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2014-08-20 08:46+0100\n"
+"PO-Revision-Date: 2014-08-20 08:46+0100\n"
+"Last-Translator: Foreman Team <foreman-dev@googlegroups.com>\n"
+"Language-Team: Foreman Team <foreman-dev@googlegroups.com>\n"
+"Language: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=INTEGER; plural=EXPRESSION;\n"
+

data/locale/gemspec.rb

@@ -0,0 +1,2 @@
+# Matches foreman_opennebula.gemspec
+_('TODO: Description of ForemanOpennebula.')