X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=bin%2Fwhatever-dl;h=a40af28fab676f14b3ac36084c3bbdb7ca7cb731;hb=HEAD;hp=9a6b8c3e23eabe2b02624fe5a38539b3de340d74;hpb=c292aca3372339f92ea6fa8fa563ffed7f4fd19c;p=dead%2Fwhatever-dl.git diff --git a/bin/whatever-dl b/bin/whatever-dl index 9a6b8c3..a40af28 100755 --- a/bin/whatever-dl +++ b/bin/whatever-dl @@ -19,98 +19,120 @@ # http://www.fsf.org/licensing/licenses/gpl.html # -# We need Pathname to get the real filesystem path -# of this script (and not, for example, the path of -# a symlink which points to it. -require 'pathname' - -# This bit of magic adds the parent directory (the -# project root) to the list of ruby load paths. -# Thus, our require statements will work regardless of -# how or from where the script was run. -executable = Pathname.new(__FILE__).realpath.to_s -$: << File.dirname(executable) + '/../' - -# We require the UriUtilities class to handle -# the download of the video URL. -require 'src/uri_utilities' - - -# The Dir.glob that's coming up doesn't use the -# Ruby library path so we need to tell it where to -# look explicitly. -websites_pattern = File.dirname(executable) + '/../src/websites/*.rb' - -# All of the website classes are located in one -# directory, so we can 'require' them automatically. -Dir.glob(websites_pattern).each do |r| - require r +# This should load everything we need for us. +require 'whatever-dl' + +# And getoptlong to check for our one option, --continue. +require 'getoptlong' + +log = Logger.new(STDOUT) +log.level = Logger::WARN + +def usage() + puts < + +Options: + -c, --continue Continue downloading a previously-attempted file. + +EOF + end -EXIT_SUCCESS = 0 -EXIT_NO_URL = 1 -EXIT_INVALID_URL = 2 -EXIT_COULDNT_GET_VIDEO_URL = 3 -EXIT_OUTPUT_FILE_ALREADY_EXISTS = 4 -EXIT_ERROR_READING_FROM_VIDEO_URL = 5 -EXIT_CONNECTION_REFUSED = 6 -EXIT_HTTP_ERROR = 7 -EXIT_ACCESS_DENIED = 8 - -# Only actually do something if this script was called -# directly (i.e. not from the tests). -if (__FILE__ == $0) then - if (ARGV.length < 1) then - # If the user didn't give us a URL, yell - # at him or her. - puts 'Usage: whatever-dl ' - Kernel.exit(EXIT_NO_URL) - end +# Default options. +options = { :continue => false } - # Factory method. - site = Website.create(ARGV[0]) +# Parse the command-line options into the options hash. +opts = GetoptLong.new(["--continue", "-c", GetoptLong::NO_ARGUMENT], + ["--help", "-h", GetoptLong::NO_ARGUMENT]) - if site.nil? - puts 'Invalid URL.' - exit(EXIT_INVALID_URL) +opts.each do |opt, arg| + case opt + when '--help' + usage() + Kernel.exit(ExitCodes::EXIT_SUCCESS) + when '--continue' + options[:continue] = true end - - video_url = site.get_video_url() +end - if video_url.nil? - puts 'Error retrieving video URL.' - exit(EXIT_COULDNT_GET_VIDEO_URL) - end +cfg = Configuration.new() - video_uri = URI.parse(video_url) - uu = UriUtilities.new() - - if File.exists?(site.get_video_filename()) - puts "Error: output file already exists. Please remove #{site.get_video_filename()}, and try again." - Kernel.exit(EXIT_OUTPUT_FILE_ALREADY_EXISTS) - end +# Warn about nonsensical options. +if options[:continue] and not cfg.download_method == 'wget' + log.warn("The --continue flag does nothing unless download_method is wget.") +end + +# Note that GetoptLong steals its arguments from ARGV, so we don't need +# to take optional arguments into account when figuring out whether or not +# we were passed a URL. +if (ARGV.length < 1) then + # If the user didn't give us a URL, yell + # at him or her. + usage() + Kernel.exit(ExitCodes::EXIT_NO_URL) +end - # Attempt to download the file, and rescue and report - # any (predictable) exceptions. - begin - puts "Fetching #{video_url}" - puts "Saving as #{site.get_video_filename()}." - puts "" - uu.download_with_progress_bar(video_uri, site.get_video_filename()) - rescue Errno::ECONNREFUSED => e - puts 'The connection to the server (to download the video file) was refused. Check your connection, and try again later.' - Kernel.exit(EXIT_CONNECTION_REFUSED) - rescue Errno::EACCES => e - puts "Access denied. Check that you have write permission to the output file/directory. Details: #{e.message}." - rescue OpenURI::HTTPError => e - puts "An HTTP error occurred while downloading the video file: #{e.message}." - Kernel.exit(EXIT_HTTP_ERROR) - end +# Factory method. +site = Website.create(ARGV[0]) - # Write an empty line at the end for aesthetic reasons. - puts "" +if site.nil? + log.error('Invalid URL.') + exit(ExitCodes::EXIT_INVALID_URL) +end - Kernel.exit(EXIT_SUCCESS) +video_url = site.get_video_url() + +if video_url.nil? + msg = 'Error retrieving video URL: ' + msg += "Site not supported, and the generic parser couldn't find any videos." + log.error(msg) + exit(ExitCodes::EXIT_COULDNT_GET_VIDEO_URL) +end + +# The Downloader class is a factory; it should decide +# which subclass we get. +puts "download_method: #{cfg.download_method}" +downloader = Downloader.create(cfg.download_method) + +# Attempt to download the file, and rescue and report +# any (predictable) exceptions. The wget downloader will +# naturally not report any of these, since it will die in +# its own process. +begin + downloader.download(video_url, + site.get_video_filename(), + site.headers(), + continue=options[:continue]) + +rescue Errno::ECONNREFUSED => e + msg = 'The connection to the server (to download the video file) ' + msg += 'was refused. Check your connection, and try again later.' + log.error(msg) + Kernel.exit(ExitCodes::EXIT_CONNECTION_REFUSED) + +rescue Errno::EACCES => e + msg = 'Access denied. Check that you have write permission ' + msg += "to the output file/directory. Details: #{e.message}." + log.error(msg) + Kernel.exit(ExitCodes::EXIT_ACCESS_DENIED) + +rescue OpenURI::HTTPError => e + msg = 'An HTTP error occurred while downloading ' + msg += " the video file: #{e.message}." + log.error(msg) + Kernel.exit(ExitCodes::EXIT_HTTP_ERROR) + +rescue IOError => e + log.error("Input/Output Error: #{e.message}") + Kernel.exit(ExitCodes::EXIT_IO_ERROR) + end + +# Write an empty line at the end for aesthetic reasons. +puts '' + +Kernel.exit(ExitCodes::EXIT_SUCCESS)