polisher 0.3 → 0.4

data/lib/event_handlers.rb

@@ -1,6 +1,12 @@
 # Gem event handler callbacks,
 # A method should exist here for every process supported by the system.
-# The method should share the same name w/ the corresponding process
+# 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>
@@ -9,92 +15,152 @@
 # 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 
+# General Public License, along with Polisher. If not, see
 # <http://www.gnu.org/licenses/>
 
+require 'erb'
 require 'gem2rpm'
 require 'net/smtp'
 
-# Convert gem into another package format.
-# Right now uses gem2rpm to create rpm spec, taking optional template file name
-# TODO extend/modify to support any other package format
-def create_package(gem, template_file = '')
-   # d/l gem into artifacts/gems dir, link it into the artifacts/SOURCES dir
-   gem_file_path = gem.download_to :dir => ARTIFACTS_DIR + "/gems"
-   gem_file = gem_file_path.split('/').last
-   File.symlink gem_file_path, ARTIFACTS_DIR + "/SOURCES/" + gem_file
-
-   # spec we are writing
-   spec_file = ARTIFACTS_DIR + "/SPECS/rubygem-#{gem.name}.spec"
-   sfh   = File.open(spec_file, "wb")
-
-   # coversion template to use, if not specified use gem2rpm default
-   template = Gem2Rpm::TEMPLATE
-   File.open(ARTIFACTS_DIR + "/templates/#{template_file}", "rb") { |file| 
-       template = file.read 
-   } unless template_file == '' || template_file.nil?
-
-   # create rpm spec w/ gem2rpm
-   Gem2Rpm::convert gem_file_path, template, sfh
-   sfh.close
+# 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
 
-   # run rpmbuild on spec
-   system("rpmbuild --define '_topdir #{ARTIFACTS_DIR}' -ba #{spec_file}")
+# 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
 
-# Update specified repository w/ latest gem artifact.
-# Right now updates specified yum repo w/ newly created gem rpm
-# TODO extend/modify to support other repository formats
-def update_repo(gem, repository)
-   # create the repository dir if it doesn't exist
-   repo_dir = ARTIFACTS_DIR + "/repos/#{repository}"
-   Dir.mkdir repo_dir unless File.directory? repo_dir
+# 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
 
-   # get the latest built rpm that matches gem name 
-   # FIXME need to incorporate version
-   gem_file = Dir[ARTIFACTS_DIR + "/RPMS/*/rubygem-#{gem.name}-*.rpm"].
-                             collect { |fn| File.new(fn) }.
-                             sort { |f1,f2| file1.mtime <=> file2.mtime }.last
+   sfh.close
 
-   # grab the architecture from the directory the file resides in  
-   arch = gem_file.path.split('.')
-   arch = arch[arch.size-2]
+   # run rpmbuild on spec to build srpm
+   system("rpmbuild --define '_topdir #{ARTIFACTS_DIR}' -bs #{spec_file}")
 
-   # copy gem into repo/arch dir, creating it if it doesn't exist
-   arch_dir = repo_dir + "/#{arch}" 
-   Dir.mkdir arch_dir unless File.directory? arch_dir
-   File.open(arch_dir + "/rubygem-#{gem.name}.rpm", 'wb') { |ofile| ofile.write gem_file.read }
+   # run mock on srpm to build rpm
+   system("mock -r #{mock_target} rebuild #{ARTIFACTS_DIR}/SRPMS/#{project.name}-#{version}-*.src.rpm")
 
-   # run createrepo to finalize the repository
-   system("createrepo #{repo_dir}")
+   # 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
 
-# run gem's test suite against specified repository
-def run_test_suite(gem, repository)
-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
 
-# notify a list of recipients of gem update
-def notify_subscribers(gem, recipients = [])
-    from    = POLISHER_CONFIG['email_from']
-    subject = POLISHER_CONFIG['email_subject']
-    body    = POLISHER_CONFIG['email_body']
-    server =  POLISHER_CONFIG['email_server']
-
-    # substitute variables into subject / body where appropriate
-    subject.gsub('#{gem_name}', gem.name)
-    body.gsub('#{gem_name}', gem.name)
-
-    msg = <<END_OF_MESSAGE
-From: #{from}
-To: #{recipients.join(',')}
-Subject: #{subject}
-
-#{body}
-END_OF_MESSAGE
-    
-   Net::SMTP.start(server) do |smtp|
-       smtp.send_message msg, from, to
-   end 
+   # 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

@@ -0,0 +1,94 @@
+# 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/polisher.rb

@@ -7,9 +7,9 @@
 # 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 
+# General Public License, along with Polisher. If not, see
 # <http://www.gnu.org/licenses/>
 
 # ruby gems
@@ -20,7 +20,7 @@ require 'fileutils'
 
 # lib/ modules
 require 'common'
-require 'event_handlers'
+require 'gem_adapter'
 require 'sinatra/url_for'
 
 # db modules
@@ -29,7 +29,7 @@ require 'db/connection'
 ##################################################################### Config
 
 # dir which generated artifacts reside
-ARTIFACTS_DIR = Sinatra::Application.artifacts_dir
+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)
 
@@ -42,79 +42,331 @@ module Polisher::DB
 end
 
 # get polisher config
-POLISHER_CONFIG = YAML::load(File.open(Sinatra::Application.polisher_config))[Sinatra::Application.environment.to_s]
+POLISHER_CONFIG = load_polisher_config(Sinatra::Application)
+
+##################################################################### Projects
 
-##################################################################### Gems
- 
-# Redirect to /gems
-get '/' do redirect '/gems'; end
+# Redirect to /projects
+get '/' do redirect '/projects.html'; end
 
-get '/gems' do
+get '/projects.html' do
+  @projects  = Project.find :all
   @sources   = Source.find :all
-  @gems      = ManagedGem.find :all
-  @processes = Event.processes 
+  @processes = Event.processes
   @version_qualifiers = Event::VERSION_QUALIFIERS
+  haml :"projects/index.html"
+end
 
-  haml :"gems/index"
+get '/projects' do
+  @projects = Project.find :all
+  haml :"projects/index", :layout => false
 end
 
-post '/gems/create' do
-  @gem = ManagedGem.new :name => params[:name], :source_id => params[:source_id]
-  @gem.save!
-  @gem.subscribe
-  redirect '/gems'
+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 '/gems/destroy/:id' do 
-  ManagedGem.delete params[:id]
-  redirect '/gems'
+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 '/gems/updated' do
-  name    = params[:name]
-  version = params[:version]
-  source_uri = ManagedGem.uri_to_source_uri(params[:gem_uri]) 
+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
 
-  source = Source.find(:first, :conditions => ["uri = ?", source_uri])
-  gem    = source.gems.all.find { |gem| gem.name == name }
-  events = gem.events.all.find_all { |event| event.applies_to_version?(version) }
-  events.each { |event| event.run }
+    # process project
+    project.released_version(version, params)
+    @result = {:success => true, :message => "successfully released project #{project.name}", :errors => []}
 
-  redirect '/gems'
+  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"
+  haml :"sources/index", :layout => false
 end
 
 post '/sources/create' do
-  @source = Source.new :name => params[:name], :uri => params[:uri]
-  @source.save!
-  redirect '/sources'
+  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 '/sources/destroy/:id' do 
-  Source.delete params[:id]
-  redirect '/sources'
+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
-  version = (params[:gem_version] != '*' ? params[:gem_version] : '')
-  @event = Event.new  :managed_gem_id  => ManagedGem.find(params[:managed_gem_id]),
-                      :process => params[:process],
-                      :gem_version => version,
-                      :version_qualifier => params[:version_qualifier],
-                      :process_options => params[:process_options]
-  @event.save!
-  redirect '/gems'
-end
-
-delete '/events/destroy/:id' do 
-  Event.delete params[:id]
-  redirect '/gems'
+  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