polisher 0.4 → 0.5.1

data/lib/event_handlers.rb

@@ -1,166 +0,0 @@
-# Gem event handler callbacks,
-# A method should exist here for every process supported by the system.
-# Once added to this module it will automatically appear in
-# db/models/Event::processes for subsequent use.
-#
-# Each method should take three parameters
-# * the event being run
-# * the version of the project being released
-# * any additional event-specific arguments in an optional hash
-#
-# Copyright (C) 2010 Red Hat, Inc.
-# Written by Mohammed Morsi <mmorsi@redhat.com>
-#
-# This program is free software, you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License
-# as published by the Free Software Foundation, either version 3
-# of the License, or (at your option) any later version.
-#
-# You should have received a copy of the the GNU Affero
-# General Public License, along with Polisher. If not, see
-# <http://www.gnu.org/licenses/>
-
-require 'erb'
-require 'gem2rpm'
-require 'net/smtp'
-
-# TODO raise some exceptions of our own here (though not neccessary as event.run will rescue everything raised, it might help w/ debugging)
-
-module EventHandlers
-
-# Download project sources
-def download_sources(event, version, args = {})
-   project       = event.project
-   args.merge!({ :dir => ARTIFACTS_DIR + "/SOURCES", :version => version })
-   args = event.process_options.to_h.merge(args) unless event.process_options.nil?
-
-   # if we've already d/l'd the sources, skip the rest of the event execution (incorporate md5sums in the future)
-   downloaded = false
-   project.sources_for_version(version).each { |src|
-     src.format_uri! args
-     downloaded = true if File.exists?(ARTIFACTS_DIR + "/SOURCES/#{src.filename}")
-   }
-   return if downloaded
-
-   # d/l projects sources into artifacts/SOURCES dir
-   project.download_to args
-end
-
-# Convert project into rpm package format.
-def create_rpm_package(event, version, args = {})
-   project       = event.project
-   args.merge!({ :version => version })
-   template_file = nil
-   mock_target = nil
-
-   unless event.process_options.nil?
-     poh = event.process_options.to_h
-     template_file = poh["spec"]
-     mock_target = poh["mock"]
-   end
-
-   # if the rpm is built, skip the rest of the event execution (really need to check if the sources changed)
-   return if !Dir[ARTIFACTS_DIR + "/RPMS/*/#{project.name}-#{version}*.rpm"].empty?
-
-   # open a handle to the spec file to write
-   spec_file = ARTIFACTS_DIR + "/SPECS/#{project.name}.spec"
-   sfh = File.open(spec_file, "wb")
-
-   # read template if specified
-   template = (template_file == '' || template_file.nil?) ? nil : File.read_all(template_file)
-
-   # if primary project source is a gem, process template w/ gem2rpm
-   primary_source = project.primary_source_for_version(version)
-   if !primary_source.nil? && primary_source.source_type == "gem"
-     gem_file_path = ARTIFACTS_DIR + '/SOURCES/' + primary_source.filename
-     template = Gem2Rpm::TEMPLATE if template.nil?
-     Gem2Rpm::convert gem_file_path, template, sfh
-
-   # otherwise just process it w/ erb
-   else
-     # setting local variables to be pulled into erb via binding below
-     params_s = ''
-     args.each { |k,v| params_s += "#{k} = '#{v}' ; " }
-     eval params_s
-
-     # setting other local variables
-     name = project.name
-     # version is already set from above
-
-     # take specified template_file and process it w/ erb,
-     # TODO raise exception if we don't have a template
-     template = File.read_all(template_file)
-     template = ERB.new(template, 0, '<>').result(binding)
-
-     # write to spec_file
-     sfh.write template
-
-   end
-
-   sfh.close
-
-   # run rpmbuild on spec to build srpm
-   system("rpmbuild --define '_topdir #{ARTIFACTS_DIR}' -bs #{spec_file}")
-
-   # run mock on srpm to build rpm
-   system("mock -r #{mock_target} rebuild #{ARTIFACTS_DIR}/SRPMS/#{project.name}-#{version}-*.src.rpm")
-
-   # copy generated rpms from /var/lib/mock/[mock_root] to ARTIFACTS/RPMS/[arches]
-   Dir["/var/lib/mock/#{mock_target}/root/builddir/build/RPMS/*.rpm"].each { |rpm|
-     arch = rpm.split(".")
-     arch = arch[arch.size-2]
-     FileUtils.mkdir_p "#{ARTIFACTS_DIR}/RPMS/#{arch}" unless File.directory? "#{ARTIFACTS_DIR}/RPMS/#{arch}"
-     FileUtils.cp rpm, "#{ARTIFACTS_DIR}/RPMS/#{arch}"
-   }
-end
-
-# Update specified yum repository w/ latest project artifact for specified version
-def update_yum_repo(event, version, args = {})
-   project    = event.project
-   repository = event.process_options
-
-   # create the repository dir if it doesn't exist
-   Dir.mkdir repository unless File.directory? repository
-
-   packages = [project.name + "-" + version]
-
-   # XXX real hacky way of getting all the packages corresponding to the project
-   # FIXME need a better solution here as any macros in the package names won't get executed properly
-   spec_file = ARTIFACTS_DIR + "/SPECS/#{project.name}.spec"
-   packages += File.read_all(spec_file).scan(/%package.*/).collect { |p|
-     ps = p.split
-     prefix = ps[ps.size-2] == "-n" ? "" : (project.name + "-")
-     prefix + p.split.last + "-" + version
-   }
-
-   # do not actually generate the repo unless a rpm is copied over
-   updated_repo = false
-
-   # copy the latest built rpms that match the packages
-   packages.each { |pkg|
-     pkg_file = Dir[ARTIFACTS_DIR + "/RPMS/*/#{pkg}*.rpm"].
-                  collect { |fn| File.new(fn) }.
-                  sort { |f1,f2| f1.mtime <=> f2.mtime }.last
-
-     unless pkg_file.nil?
-       # grab the architecture from the directory the src file resides in
-       arch = pkg_file.path.split('.')
-       arch = arch[arch.size-2]
-
-       pkg_file_name = pkg_file.path.split('/').last
-
-       # copy project into repo/arch dir, creating it if it doesn't exist
-       arch_dir = repository + "/#{arch}"
-       Dir.mkdir arch_dir unless File.directory? arch_dir
-       unless File.exists?(arch_dir + "/#{pkg_file_name}") # TODO need to incorporate a md5sum comparison here
-         updated_repo = true
-         File.write(arch_dir + "/#{pkg_file_name}", File.read_all(pkg_file.path))
-       end
-     end
-   }
-
-   # run createrepo to finalize the repository
-   system("createrepo #{repository}") if updated_repo
-end
-
-end #module EventHandlers

data/lib/gem_adapter.rb

@@ -1,94 +0,0 @@
-# Gem adapter, provides interface to many gem routines
-#
-# Copyright (C) 2010 Red Hat, Inc.
-# Written by Mohammed Morsi <mmorsi@redhat.com>
-#
-# This program is free software, you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License
-# as published by the Free Software Foundation, either version 3
-# of the License, or (at your option) any later version.
-# 
-# You should have received a copy of the the GNU Affero
-# General Public License, along with Polisher. If not, see 
-# <http://www.gnu.org/licenses/>
-
-module Polisher
-module GemAdapter
-
-   # Subscribe callback_url to gem updates from the specified source.
-   def subscribe(source, callback_url, gem_api_key)
-      raise ArgumentError, "must specify valid source, callback url, and api key" if source.nil? || callback_url.class != String || gem_api_key.class != String
-
-      subscribe_path = '/api/v1/web_hooks'
-      headers = { 'Authorization' => gem_api_key }
-      data = "gem_name=#{source.name}&url=#{callback_url}"
-
-      begin
-        http = Net::HTTP.new(URI.parse(source.uri).host, 80)
-        res = http.post(subscribe_path, data, headers)
-        raise RuntimeError unless res.is_a?(Net::HTTPSuccess)
-      rescue Exception => e
-        raise RuntimeError, "could not subscribe to gem #{source.name} at #{source.uri}#{subscribe_path}"
-      end
-   end
-   module_function :subscribe
-
-   # Determine if we are subscribed to gem specified by source with the specified gem_api_key
-   def subscribed?(source, gem_api_key)
-      raise ArgumentError, "must specify valid source and api key" if source.nil? || gem_api_key.class != String
-
-      subscribe_path = '/api/v1/web_hooks.json'
-      headers = { 'Authorization' => gem_api_key }
-
-      begin
-        http = Net::HTTP.new(URI.parse(source.uri).host, 80)
-        res  = http.get(subscribe_path, headers).body
-        raise RuntimeError if res.class == Net::HTTPNotFound
-        res  = JSON.parse(res)
-        return res.has_key?(source.name)
-
-      rescue Exception => e
-        raise RuntimeError, "could not connect to gem source at #{source.uri}#{subscribe_path}"
-      end
-   end
-   module_function :subscribed?
-
-   # Unsubscribe to updates to the gem specified by source w/  the specified callback_url and api_key
-   def unsubscribe(source, callback_url, gem_api_key)
-      return unless subscribed?(source, gem_api_key)
-      raise ArgumentError, "must specify valid source, callback url, and api key" if source.nil? || callback_url.class != String || gem_api_key.class != String
-
-      subscribe_path = "/api/v1/web_hooks/remove?gem_name=#{source.name}&url=#{callback_url}"
-      headers = { 'Authorization' => gem_api_key }
-
-      begin
-        http = Net::HTTP.new(URI.parse(source.uri).host, 80)
-        res = http.delete(subscribe_path, headers)
-        raise RuntimeError if res.class == Net::HTTPNotFound
-      rescue Exception => e
-        raise RuntimeError, "could not delete gem #{source.name} via #{source.uri}#{subscribe_path}"
-      end
-   end
-   module_function :unsubscribe
-
-   # Return hash of gem attributes/values retreived from remote source
-   def get_info(source)
-     info = nil
-     source_uri = URI.parse(source.uri).host
-     get_path = "/api/v1/gems/#{source.name}.json"
-     begin
-       Net::HTTP.start(source_uri, 80) { |http|
-          res = http.get(get_path).body
-          raise RuntimeError if res.class == Net::HTTPNotFound
-          info = JSON.parse(res)
-       }
-     rescue Exception => e
-      raise RuntimeError, "could not get info for gem #{source.name} via #{source.uri}#{get_path}"
-     end
-
-     return info
-   end
-   module_function :get_info
-
-end # module GemAdapter
-end # module Polisher

data/lib/sinatra/url_for.rb

@@ -1,40 +0,0 @@
-# copied from http://git.fedoraproject.org/git/?p=deltacloud/core.git;a=blob;f=server/libexec/lib/sinatra/url_for.rb
-
-module Sinatra
-  module UrlForHelper
-    # Construct a link to +url_fragment+, which should be given relative to
-    # the base of this Sinatra app.  The mode should be either
-    # <code>:path_only</code>, which will generate an absolute path within
-    # the current domain (the default), or <code>:full</code>, which will
-    # include the site name and port number.  (The latter is typically
-    # necessary for links in RSS feeds.)  Example usage:
-    #
-    #   url_for "/"            # Returns "/myapp/"
-    #   url_for "/foo"         # Returns "/myapp/foo"
-    #   url_for "/foo", :full  # Returns "http://example.com/myapp/foo"
-    #--
-    # See README.rdoc for a list of some of the people who helped me clean
-    # up earlier versions of this code.
-    def url_for url_fragment, mode=:path_only
-      case mode
-      when :path_only
-        base = request.script_name
-      when :full
-        scheme = request.scheme
-        if (scheme == 'http' && request.port == 80 ||
-            scheme == 'https' && request.port == 443)
-          port = ""
-        else
-          port = ":#{request.port}"
-        end
-        request_host = HOSTNAME ? HOSTNAME : request.host
-        base = "#{scheme}://#{request_host}#{port}#{request.script_name}"
-      else
-        raise TypeError, "Unknown url_for mode #{mode}"
-      end
-      "#{base}#{url_fragment}"
-    end
-  end
-
-  helpers UrlForHelper
-end

data/polisher.rb

@@ -1,372 +0,0 @@
-# ruby gem polisher REST interface
-#
-# Copyright (C) 2010 Red Hat, Inc.
-# Written by Mohammed Morsi <mmorsi@redhat.com>
-#
-# This program is free software, you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License
-# as published by the Free Software Foundation, either version 3
-# of the License, or (at your option) any later version.
-#
-# You should have received a copy of the the GNU Affero
-# General Public License, along with Polisher. If not, see
-# <http://www.gnu.org/licenses/>
-
-# ruby gems
-require 'rubygems'
-require 'haml'
-require 'sinatra'
-require 'fileutils'
-
-# lib/ modules
-require 'common'
-require 'gem_adapter'
-require 'sinatra/url_for'
-
-# db modules
-require 'db/connection'
-
-##################################################################### Config
-
-# dir which generated artifacts reside
-ARTIFACTS_DIR = File.expand_path(Sinatra::Application.artifacts_dir)
-
-create_missing_polisher_dirs(:artifacts_dir => ARTIFACTS_DIR, :db_data_dir => Sinatra::Application.db_data_dir, :log_dir => Sinatra::Application.log_dir)
-
-# startup logger
-LOGGER = Logger.new(Sinatra::Application.log_dir + '/polisher.log')
-
-# connect to db
-module Polisher::DB
-   connect load_config(Sinatra::Application.db_config, Sinatra::Application.environment), LOGGER
-end
-
-# get polisher config
-POLISHER_CONFIG = load_polisher_config(Sinatra::Application)
-
-##################################################################### Projects
-
-# Redirect to /projects
-get '/' do redirect '/projects.html'; end
-
-get '/projects.html' do
-  @projects  = Project.find :all
-  @sources   = Source.find :all
-  @processes = Event.processes
-  @version_qualifiers = Event::VERSION_QUALIFIERS
-  haml :"projects/index.html"
-end
-
-get '/projects' do
-  @projects = Project.find :all
-  haml :"projects/index", :layout => false
-end
-
-post '/projects/create' do
-  begin
-    if params[:name].nil? || params[:name] == ""
-      raise ArgumentError, "/projects/create received an invalid name(#{params[:name]})"
-    end
-
-    @project = Project.new :name => params[:name]
-    @project.save!
-
-    @result = {:success => true, :message => "successfully created project #{@project.name}", :errors => []}
-
-  rescue Exception => e
-    @result = {:success => false, :message => "failed to created project due to error #{e}", :errors => [e]}
-    @project.errors.each_full { |e| @result[:errors] << e } unless @project.nil?
-  end
-
-  haml :"result", :layout => false
-end
-
-delete '/projects/destroy/:id' do
-  begin
-    if params[:id].nil?
-      raise ArgumentError, "/projects/destroy/:id received an invalid id(#{params[:id]})"
-    end
-
-    project = Project.find(params[:id])
-    if project.nil?
-      raise ArgumentError, "/projects/destroy/#{params[:id]} could not find project"
-    end
-
-    project_name = project.name
-    Project.delete params[:id]
-    @result = {:success => true, :message => "successfully deleted project #{project_name}", :errors => []}
-
-  rescue Exception => e
-    @result = {:success => false, :message => "failed to delete project due to error #{e}", :errors => [e]}
-  end
-
-  haml :"result", :layout => false
-end
-
-post '/projects/released' do
-  begin
-    if params[:name].nil? || params[:version].nil?
-      raise ArgumentError, "/projects/released received an invalid name(#{params[:name]}) or version(#{params[:version]})"
-    end
-
-    name    = params[:name]
-    version = params[:version]
-    project = Project.find(:first, :conditions => ["name = ?", name])
-    if project.nil?
-      raise ArgumentError, "/projects/released could not find project from name #{name}"
-    end
-
-    # process project
-    project.released_version(version, params)
-    @result = {:success => true, :message => "successfully released project #{project.name}", :errors => []}
-
-  rescue Exception => e
-    @result = {:success => false, :message => "failed to release project due to error #{e}", :errors => [e]}
-  end
-
-  haml :"result", :layout => false
-end
-
-##################################################################### Sources
-
-get '/sources.html' do
-  @sources  = Source.find :all
-  @projects = Project.find :all
-  haml :"sources/index.html"
-end
-
-get '/sources' do
-  @sources = Source.find :all
-  haml :"sources/index", :layout => false
-end
-
-post '/sources/create' do
-  begin
-    if params[:uri].nil? || params[:name].nil? || params[:source_type].nil?
-      raise ArgumentError, "/sources/create received an invalid uri(#{params[:uri]}), name(#{params[:name]}) or source_type(#{params[:source_type]})"
-    end
-
-    @source = Source.new(:uri => params[:uri], :name => params['name'], :source_type => params[:source_type])
-    @source.save!
-
-    @result = {:success => true, :message => "successfully created source #{@source.uri}", :errors => []}
-
-  rescue Exception => e
-    @result = {:success => false, :message => "failed to create source due to error #{e}", :errors => [e]}
-    @source.errors.each_full { |e| @result[:errors] << e } unless @source.nil?
-  end
-
-  haml :"result", :layout => false
-end
-
-delete '/sources/destroy/:id' do
-  begin
-    if params[:id].nil?
-      raise ArgumentError, "/sources/destroy/:id received an invalid id(#{params[:id]})"
-    end
-
-    source = Source.find(params[:id])
-    if source.nil?
-      raise ArgumentError, "/sources/destroy/#{params[:id]} could not find source"
-    end
-
-    source_uri = source.uri
-    Source.delete params[:id]
-
-    @result = {:success => true, :message => "successfully deleted source #{source_uri}", :errors => []}
-
-  rescue Exception => e
-    @result = {:success => false, :message => "failed to delete source due to error #{e}", :errors => [e]}
-  end
-
-  haml :"result", :layout => false
-end
-
-post '/sources/released' do
-  begin
-    if params[:name].nil? || params[:version].nil?
-      raise ArgumentError, "/sources/released received an invalid name(#{params[:name]}) or version(#{params[:version]})"
-    end
-
-    name    = params[:name]
-    version = params[:version]
-    # we also have gem_uri for gem sources
-
-    source = Source.find(:first, :conditions => ["name = ?", name])
-    if source.nil?
-      raise ArgumentError, "/sources/released could not find source from name #{name}"
-    end
-
-    # find projects which include this source
-    source.project_source_versions_for_version(version).each { |ps|
-      # if we can't determine project version, use source version
-      project_version = ps.project_version.nil? ? version : ps.project_version
-
-      # invoke a release on the project
-      ps.project.released_version(version, params)
-    }
-
-    @result = {:success => true, :message => "successfully released source #{name}", :errors => []}
-
-  rescue Exception => e
-    @result = {:success => false, :message => "failed to release source due to error #{e}", :errors => [e]}
-  end
-
-  haml :"result", :layout => false
-end
-
-##################################################################### ProjectSourceVersions
-
-post '/project_source_versions/create' do
-  begin
-    if params[:project_id].nil? ||  params[:source_id].nil?
-      raise ArgumentError, "/project_source_versions/create received an invalid project_id(#{params[:project_id]}) or source_id(#{params[:source_id]})"
-    end
-
-    project = Project.find(params[:project_id])
-    source  = Source.find(params[:source_id])
-    if project.nil? || source.nil?
-      raise ArgumentError, "/project_source_versions/create could not find project or source from ids"
-    end
-
-    ps = ProjectSourceVersion.new :project => project, :source => source,
-                            :project_version   => params[:project_version],
-                            :source_version    => params[:source_version],
-                            :source_uri_params => params[:source_uri_params],
-                            :primary_source    => params[:primary_source]
-
-    ps.save!
-    @result = {:success => true, :message => "successfully created project source", :errors => []}
-
-  rescue Exception => e
-    @result = {:success => false, :message => "failed to create project source due to error #{e}", :errors => [e]}
-  end
-
-  haml :"result", :layout => false
-end
-
-delete '/project_source_versions/destroy/:id' do
-  begin
-    if params[:id].nil?
-      raise ArgumentError, "/project_source_versions/destroy/:id received an invalid id(#{params[:id]})"
-    end
-
-    ps = ProjectSourceVersion.find(params[:id])
-    if ps.nil?
-      raise ArgumentError, "/project_source_versions/destroy/#{params[:id]} could not find project source"
-    end
-
-    ProjectSourceVersion.delete params[:id]
-    @result = {:success => true, :message => "successfully deleted project source", :errors => []}
-
-  rescue Exception => e
-    @result = {:success => false, :message => "failed to delete project source due to error #{e}", :errors => [e]}
-  end
-
-  haml :"result", :layout => false
-end
-
-##################################################################### ProjectDependencies
-
-post '/project_dependencies/create' do
-  begin
-    if params[:project_id].nil? ||  params[:depends_on_project_id].nil?
-      raise ArgumentError, "/project_dependencies/create received an invalid project_id(#{params[:project_id]}) or depends_on_project_id(#{params[:depends_on_project_id]})"
-    end
-
-    project = Project.find(params[:project_id])
-    depends_on = Project.find(params[:depends_on_project_id])
-    if project.nil? || depends_on.nil?
-      raise ArgumentError, "/project_dependencies/create could not find projects w/ specified ids(#{params[:project_id]}/#{params[:depends_on_project_id]})"
-    end
-
-    project_version    = (params[:project_version]    != '*' ? params[:project_version]   : nil)
-    depends_on_version = (params[:depends_on_project_version] != '*' ? params[:depends_on_project_version]: nil)
-    @pd = ProjectDependency.new  :project => project, :depends_on_project => depends_on,
-                                 :project_version => project_version, :depends_on_project_version => depends_on_version,
-                                 :depends_on_project_params => params[:depends_on_project_params]
-    @pd.save!
-
-    @result = {:success => true, :message => "successfully created project dependency", :errors => []}
-
-  rescue Exception => e
-    @result = {:success => false, :message => "failed to created project dependency due to error #{e}", :errors => [e]}
-    @pd.errors.each_full { |e| @result[:errors] << e } unless @event.nil?
-  end
-
-  haml :"result", :layout => false
-end
-
-delete '/project_dependencies/destroy/:id' do
-  begin
-    if params[:id].nil?
-      raise ArgumentError, "/project_dependencies/destroy/:id received an invalid id(#{params[:id]})"
-    end
-
-    pd = ProjectDependency.find(params[:id])
-    if pd.nil?
-      raise ArgumentError, "/project_dependencies/destroy/#{params[:id]} could not find project dependency"
-    end
-
-    ProjectDependency.delete params[:id]
-    @result = {:success => true, :message => "successfully deleted project dependency", :errors => []}
-
-  rescue Exception => e
-    @result = {:success => false, :message => "failed to delete project dependency due to error #{e}", :errors => [e]}
-  end
-
-  haml :"result", :layout => false
-end
-
-##################################################################### Events
-
-post '/events/create' do
-  begin
-    if params[:project_id].nil? ||  params[:process].nil?
-      raise ArgumentError, "/events/create received an invalid project_id(#{params[:project_id]}) or process(#{params[:process]})"
-    end
-
-    project = Project.find(params[:project_id])
-    if project.nil?
-      raise ArgumentError, "/events/create could not find project w/ specified id(#{params[:project_id]})"
-    end
-
-    version           = (params[:version]       != '*' ? params[:version]       : nil)
-    version_qualifier = (params[:version_qualifier] != ''  ? params[:version_qualifier] : nil)
-    @event = Event.new  :project => project,
-                        :version => version,
-                        :version_qualifier => version_qualifier,
-                        :process => params[:process],
-                        :process_options => params[:process_options]
-    @event.save!
-
-    @result = {:success => true, :message => "successfully created event", :errors => []}
-
-  rescue Exception => e
-    @result = {:success => false, :message => "failed to created event due to error #{e}", :errors => [e]}
-    @event.errors.each_full { |e| @result[:errors] << e } unless @event.nil?
-  end
-
-  haml :"result", :layout => false
-end
-
-delete '/events/destroy/:id' do
-  begin
-    if params[:id].nil?
-      raise ArgumentError, "/events/destroy/:id received an invalid id(#{params[:id]})"
-    end
-
-    event = Event.find(params[:id])
-    if event.nil?
-      raise ArgumentError, "/events/destroy/#{params[:id]} could not find event"
-    end
-
-    Event.delete params[:id]
-    @result = {:success => true, :message => "successfully deleted event", :errors => []}
-
-  rescue Exception => e
-    @result = {:success => false, :message => "failed to delete event due to error #{e}", :errors => [e]}
-  end
-
-  haml :"result", :layout => false
-end