624 lines
20 KiB
Ruby
624 lines
20 KiB
Ruby
Rails.logger = Logger.new(STDOUT)
|
|
|
|
namespace :jam_tracks do
|
|
|
|
task import_click_tracks: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Helbing'
|
|
JamTrackImporter.import_click_tracks
|
|
end
|
|
|
|
task generate_jmep: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Tency'
|
|
JamTrackImporter.load_marks_approved
|
|
JamTrackImporter.generate_jmeps
|
|
end
|
|
|
|
task generate_jmep_paris: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Paris'
|
|
JamTrackImporter.load_marks_approved
|
|
JamTrackImporter.generate_jmeps
|
|
end
|
|
|
|
task dry_run: :environment do |task, args|
|
|
if ENV['STORAGE']
|
|
JamTrackImporter.storage_format = ENV['STORAGE']
|
|
end
|
|
JamTrackImporter.dry_run
|
|
end
|
|
|
|
# valid values for STORAGE
|
|
# Helbing
|
|
task dry_run: :environment do |task, args|
|
|
if ENV['STORAGE']
|
|
JamTrackImporter.storage_format = ENV['STORAGE']
|
|
end
|
|
JamTrackImporter.dry_run
|
|
end
|
|
|
|
task create_clevie: :environment do |task, args|
|
|
licensor = JamTrackLicensor.new()
|
|
licensor.name = 'Steely & Clevie'
|
|
licensor.slug = 'steely-and-clevie'
|
|
licensor.save!
|
|
end
|
|
task tency_dry_run: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Tency'
|
|
JamTrackImporter.dry_run
|
|
end
|
|
|
|
task paris_dry_run: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Paris'
|
|
JamTrackImporter.dry_run
|
|
end
|
|
|
|
task drumma_dry_run: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Drumma'
|
|
JamTrackImporter.dry_run
|
|
end
|
|
|
|
task clevie_dry_run: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Clevie'
|
|
JamTrackImporter.dry_run
|
|
end
|
|
|
|
task paris_create_masters: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Paris'
|
|
JamTrackImporter.create_masters
|
|
end
|
|
|
|
task timtracks_dry_run: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'TimTracks'
|
|
JamTrackImporter.dry_run
|
|
end
|
|
|
|
task tency_create_masters: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Tency'
|
|
JamTrackImporter.create_masters
|
|
end
|
|
task drumma_create_masters: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Drumma'
|
|
JamTrackImporter.create_masters
|
|
end
|
|
|
|
task tency_licensor_yaml: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Tency'
|
|
JamTrackImporter.add_tency_metadata
|
|
end
|
|
|
|
task tency_create_master: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Tency'
|
|
|
|
path = ENV['TRACK_PATH']
|
|
|
|
if !path
|
|
puts "TRACK_PATH must be set to something like audio/AC DC/Back in Black or mapped/50 Cent - In Da Club - 12401"
|
|
exit(1)
|
|
end
|
|
|
|
JamTrackImporter.create_master(path)
|
|
end
|
|
|
|
task clevie_create_master: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Clevie'
|
|
|
|
path = ENV['TRACK_PATH']
|
|
|
|
if !path
|
|
puts "TRACK_PATH must be set to something like audio/AC DC/Back in Black or mapped/50 Cent - In Da Club - 12401"
|
|
exit(1)
|
|
end
|
|
|
|
JamTrackImporter.create_master(path)
|
|
end
|
|
|
|
task tency_delta: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Tency'
|
|
JamTrackImporter.tency_delta
|
|
end
|
|
|
|
task sync: :environment do |task, args|
|
|
path = ENV['TRACK_PATH']
|
|
|
|
if !path
|
|
puts "TRACK_PATH must be set to something like audio/AC DC/Back in Black or mapped/50 Cent - In Da Club - 12401"
|
|
exit(1)
|
|
end
|
|
|
|
if ENV['STORAGE_FORMAT']
|
|
JamTrackImporter.storage_format = ENV['STORAGE_FORMAT']
|
|
elsif path.start_with?('mapped')
|
|
JamTrackImporter.storage_format = 'Tency'
|
|
end
|
|
|
|
JamTrackImporter.synchronize_from_meta("#{path}/meta.yml", skip_audio_upload: false)
|
|
end
|
|
|
|
task resync_audio: :environment do |task, args|
|
|
path = ENV['TRACK_PATH']
|
|
|
|
if !path
|
|
puts "TRACK_PATH must be set to something like AD DC/Back in Black"
|
|
exit(1)
|
|
end
|
|
|
|
if path.start_with?('mapped')
|
|
JamTrackImporter.storage_format = 'Paris'
|
|
end
|
|
|
|
JamTrackImporter.synchronize_from_meta("#{path}/meta.yml", resync_audio: true, skip_audio_upload: false)
|
|
end
|
|
|
|
task resync_instruments: :environment do |task, args|
|
|
JamTrackImporter.storage_format = ENV['STORAGE_FORMAT']
|
|
JamTrackImporter.resync_instruments(JamTrackLicensor.find_by_name!('Stockton Helbing'))
|
|
end
|
|
|
|
|
|
task fix_slugs: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Paris'
|
|
JamTrackImporter.fix_slugs(JamTrackLicensor.find_by_name!('Paris Music'))
|
|
end
|
|
|
|
task fix_paris_artists: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Paris'
|
|
JamTrackImporter.fix_artist_song_name(JamTrackLicensor.find_by_name!('Paris Music'))
|
|
end
|
|
|
|
task dump_missing_masters: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Paris'
|
|
JamTrackImporter.missing_masters(JamTrackLicensor.find_by_name!('Paris Music'))
|
|
end
|
|
|
|
task tency_genre_dump: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Tency'
|
|
JamTrackImporter.tency_genre_dump
|
|
end
|
|
|
|
|
|
task paris_genre_dump: :environment do |task, args|
|
|
|
|
JamTrackImporter.storage_format = 'Paris'
|
|
|
|
File.open("/Users/seth/workspace/backups/paris/bucket_contents.txt", "r").each_line do |line|
|
|
|
|
mapped_index = line.index('mapped')
|
|
if mapped_index
|
|
path = line[(mapped_index + 'mapped/'.length)..-1]
|
|
bits = path.split('/')
|
|
if bits[-1].strip.end_with?('.wav')
|
|
# got a wave file. let's peek
|
|
|
|
if bits.length == 2
|
|
metalocation = "mapped/#{bits[0]}/#{bits[1]}/meta.yml"
|
|
importer = JamTrackImporter.new
|
|
importer.storage_format = 'Paris'
|
|
|
|
meta = importer.parse_metalocation(metalocation)
|
|
if meta.length != 6
|
|
raise "UNknOWN META! #{meta.inspect}"
|
|
end
|
|
|
|
song_id = JamTrackImporter.extract_paris_song_id(metalocation)
|
|
raise "unknown song id in #{metalocation}" if song_id.nil?
|
|
else
|
|
raise "UNKNOWN!!!"
|
|
end
|
|
|
|
end
|
|
|
|
|
|
end
|
|
end
|
|
|
|
|
|
JamTrackImporter.paris_genre_dump
|
|
end
|
|
|
|
task sync_paris: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Paris'
|
|
JamTrackImporter.synchronize_all(skip_audio_upload: false)
|
|
end
|
|
|
|
task sync_tency: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Tency'
|
|
JamTrackImporter.synchronize_all(skip_audio_upload: false)
|
|
end
|
|
|
|
task sync_tim_tracks: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'TimTracks'
|
|
JamTrackImporter.synchronize_all(skip_audio_upload: false)
|
|
end
|
|
|
|
task sync_helbing: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Helbing'
|
|
JamTrackImporter.synchronize_all(skip_audio_upload: false)
|
|
end
|
|
|
|
task sync_clevie: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Clevie'
|
|
JamTrackImporter.synchronize_all(skip_audio_upload: false)
|
|
end
|
|
|
|
task tency_dups: :environment do |task, args|
|
|
|
|
end
|
|
task onboarding_exceptions: :environment do |task, args|
|
|
JamTrackImporter.onboarding_exceptions
|
|
end
|
|
|
|
task generate_slugs: :environment do |task, arg|
|
|
JamTrackImporter.generate_slugs
|
|
end
|
|
|
|
task generate_mp3_aac_stems: :environment do |task, arg|
|
|
JamTrackImporter.storage_format = 'default'
|
|
JamTrackImporter.generate_mp3_aac_stems(JamTrackImporter.storage_format)
|
|
|
|
JamTrackImporter.storage_format = 'Tency'
|
|
JamTrackImporter.generate_mp3_aac_stems(JamTrackImporter.storage_format)
|
|
end
|
|
|
|
task sync_all: :environment do |task, args|
|
|
JamTrackImporter.synchronize_all(skip_audio_upload: false)
|
|
end
|
|
|
|
task sync_all_dev: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'default'
|
|
JamTrackImporter.synchronize_all(skip_audio_upload: true)
|
|
end
|
|
|
|
task sync_previews_all: :environment do |task, arg|
|
|
JamTrackImporter.synchronize_previews
|
|
end
|
|
|
|
task sync_master_preview_all: :environment do |task, args|
|
|
importer = JamTrackImporter.synchronize_jamtrack_master_previews
|
|
end
|
|
|
|
task sync_master_aac: :environment do |task, args|
|
|
JamTrackImporter.synchronize_jamtrack_aac_previews
|
|
end
|
|
|
|
task sync_click_mp3_to_wav: :environment do |task, args|
|
|
JamTrackImporter.storage_format = 'Helbing'
|
|
JamTrackImporter.convert_click_track_to_wavs
|
|
end
|
|
|
|
# popuplate preview info without uploading/processing audio files (use what's in S3)
|
|
task sync_previews_dev: :environment do |task, args|
|
|
JamTrackImporter.synchronize_previews_dev
|
|
end
|
|
|
|
# syncs just one master track for a give JamTrack
|
|
task sync_master_preview: :environment do |task, args|
|
|
plan_code = ENV['PLAN_CODE']
|
|
if !plan_code
|
|
puts "PLAN_CODE must be set to something like jamtrack-acdc-backinblack"
|
|
exit(1)
|
|
end
|
|
|
|
jam_track = JamTrack.find_by_plan_code!(plan_code)
|
|
|
|
importer = JamTrackImporter.synchronize_jamtrack_master_preview(jam_track)
|
|
|
|
if importer.reason.nil? || importer.reason == "success" || importer.reason == "jam_track_exists"
|
|
puts("#{importer.name} #{importer.reason}")
|
|
else
|
|
puts("#{importer.name} failed to import.")
|
|
puts("#{importer.name} reason=#{importer.reason}")
|
|
puts("#{importer.name} detail=#{importer.detail}")
|
|
end
|
|
end
|
|
|
|
task sync_duration_all: :environment do |task, args|
|
|
importer = JamTrackImporter.synchronize_durations
|
|
end
|
|
|
|
# syncs just one master track for a give JamTrack
|
|
task sync_duration: :environment do |task, args|
|
|
plan_code = ENV['PLAN_CODE']
|
|
if !plan_code
|
|
puts "PLAN_CODE must be set to something like jamtrack-acdc-backinblack"
|
|
exit(1)
|
|
end
|
|
|
|
jam_track = JamTrack.find_by_plan_code!(plan_code)
|
|
|
|
importer = JamTrackImporter.synchronize_duration(jam_track)
|
|
|
|
if importer.reason.nil? || importer.reason == "success" || importer.reason == "jam_track_exists"
|
|
puts("#{importer.name} #{importer.reason}")
|
|
else
|
|
puts("#{importer.name} failed to import.")
|
|
puts("#{importer.name} reason=#{importer.reason}")
|
|
puts("#{importer.name} detail=#{importer.detail}")
|
|
end
|
|
end
|
|
|
|
task download_masters: :environment do |task, arg|
|
|
JamTrackImporter.download_masters
|
|
end
|
|
|
|
|
|
task tency: :environment do |task, arg|
|
|
mapper = TencyStemMapping.new
|
|
mapper.correlate
|
|
end
|
|
|
|
task touch: :environment do |task, arg|
|
|
JamTrack.all.each do |jam_track|
|
|
jam_track.jmep_json_generate
|
|
jam_track.save!
|
|
end
|
|
end
|
|
|
|
task generate_private_key: :environment do |task, arg|
|
|
JamTrackRight.all.each do |right|
|
|
if right.private_key_44.nil? || right.private_key_48.nil?
|
|
|
|
if right.private_key_44.nil? && right.private_key_48
|
|
right.private_key_44 = right.private_key_48
|
|
puts "COPY 48 > 44"
|
|
elsif right.private_key_48.nil? && right.private_key_44
|
|
right.private_key_48 = right.private_key_44
|
|
puts "COPY 44 > 48"
|
|
elsif right.private_key_48.nil? && right.private_key_44.nil?
|
|
rsa_key = OpenSSL::PKey::RSA.new(1024)
|
|
key = rsa_key.to_pem()
|
|
right.private_key_44 = key
|
|
right.private_key_48 = key
|
|
puts "GEN 44 + 48"
|
|
end
|
|
|
|
right.save
|
|
else
|
|
puts "OK 44 + 48"
|
|
end
|
|
end
|
|
end
|
|
|
|
task gen_jamtrack_files: :environment do |task, arg|
|
|
|
|
instruments = Instrument.all
|
|
jam_tracks = JamTrack.where(status: 'Production').order('original_artist, name')
|
|
|
|
Dir.mktmpdir do |tmp_dir|
|
|
csv_file = File.join(tmp_dir, "production.csv")
|
|
pdf_file = File.join(tmp_dir, "production.pdf")
|
|
|
|
|
|
CSV.open(csv_file, "wb") do |csv|
|
|
header = ['Artist', 'Name', 'Link', 'Click Track', 'Count-In', 'Added to Catalog']
|
|
|
|
instruments.each do |instrument|
|
|
header << instrument.description
|
|
end
|
|
|
|
csv << header
|
|
jam_tracks.each do |jam_track|
|
|
row = []
|
|
row << jam_track.original_artist
|
|
row << jam_track.name
|
|
row << Rails.application.config.external_root_url + Rails.application.routes.url_helpers.individual_jamtrack_path(jam_track.slug)
|
|
row << (jam_track.click_track.nil? ? 'no' : 'yes')
|
|
row << (jam_track.has_count_in? ? 'yes' : 'no')
|
|
row << jam_track.created_at.to_date.to_s
|
|
|
|
tracks = jam_track.jam_track_tracks
|
|
|
|
instruments.each do |instrument|
|
|
|
|
match = false
|
|
tracks.each do |track|
|
|
if track.track_type == 'Track' && track.instrument_id == instrument.id
|
|
match = true
|
|
break
|
|
end
|
|
end
|
|
|
|
row << (match ? 'yes' : 'no')
|
|
end
|
|
csv << row
|
|
end
|
|
end
|
|
|
|
Prawn::Document.generate(pdf_file) do
|
|
|
|
text "Current JamTracks Catalog by JamKazam", align: :center, size:18, inline_format: true
|
|
text "Last Updated: #{Time.now.strftime('%m/%d/%Y')}", align: :center
|
|
move_down 10
|
|
text "This PDF was downloaded from <link href=\"https://s3.amazonaws.com/jamkazam-public/public/lists/all-jamkazam-jamtracks.pdf\"><color rgb='0000FF'>here</color></link>.", inline_format: true, font_size:12
|
|
move_down 10
|
|
text "The CSV version can be downloaded from <link href=\"https://s3.amazonaws.com/jamkazam-public/public/lists/all-jamkazam-jamtracks.csv\"><color rgb='0000FF'>here</color></link>. It also contains instrument info.", inline_format: true, font_size:12
|
|
move_down 20
|
|
pdf_data= []
|
|
|
|
header = ['Artist', 'Song Name', 'Site Link', 'Click Track', 'Count In', 'Added to Catalog']
|
|
|
|
columns = header.length
|
|
|
|
pdf_data << header
|
|
|
|
jam_tracks.each do |jam_track|
|
|
table_row = []
|
|
table_row << jam_track.original_artist
|
|
table_row << jam_track.name
|
|
table_row << "<link href=\"#{Rails.application.config.external_root_url + Rails.application.routes.url_helpers.individual_jamtrack_path(jam_track.slug)}\"><color rgb='0000FF'>link </color></link>"
|
|
table_row << (jam_track.click_track.nil? ? 'no' : 'yes')
|
|
table_row << (jam_track.has_count_in? ? 'yes' : 'no')
|
|
table_row << jam_track.created_at.to_date.to_s
|
|
|
|
pdf_data << table_row
|
|
end
|
|
|
|
|
|
table(pdf_data, :cell_style => {inline_format: true}, header: true, row_colors: ["D0D0D0", "F0F0F0"])
|
|
end
|
|
|
|
|
|
s3_manager = S3Manager.new(Rails.application.config.aws_bucket_public, Rails.application.config.aws_access_key_id, Rails.application.config.aws_secret_access_key)
|
|
|
|
s3_manager.upload('public/lists/all-jamkazam-jamtracks.csv', csv_file, content_type: 'text/csv')
|
|
s3_manager.upload('public/lists/all-jamkazam-jamtracks.pdf', pdf_file, content_type: 'application/pdf')
|
|
|
|
FileUtils.mv(csv_file, 'tmp/test.csv')
|
|
FileUtils.mv(pdf_file, 'tmp/test.pdf')
|
|
end
|
|
end
|
|
|
|
task gen_jamtrack_manifest: :environment do |task, arg|
|
|
|
|
|
|
# DOWNLOAD_AUDIO =
|
|
max = ENV['MAX_JAMTRACKS'].to_i
|
|
if max == 0
|
|
max = nil
|
|
end
|
|
puts "MAX JAMTRACKS #{max}"
|
|
|
|
jam_tracks = JamTrack.includes([:jam_track_tracks,
|
|
{genres_jam_tracks: :genres},
|
|
{jam_track_tracks: :instrument},
|
|
:genres]).where(status: 'Production').order('original_artist, name')
|
|
private_bucket = Rails.application.config.aws_bucket
|
|
s3_manager = S3Manager.new(private_bucket, Rails.application.config.aws_access_key_id, Rails.application.config.aws_secret_access_key)
|
|
|
|
tmp_dir = Dir.mktmpdir
|
|
FileUtils.mkdir_p tmp_dir
|
|
|
|
puts "tmp_dir=#{tmp_dir}"
|
|
|
|
csv_file = File.join(tmp_dir, "manifest.csv")
|
|
top_folder = File.join(tmp_dir, "audio")
|
|
FileUtils.mkdir_p(top_folder)
|
|
|
|
CSV.open(csv_file, "wb") do |csv|
|
|
header = ['JamTrackId', 'TrackId', 'Artist', 'Song', 'Instrument', 'Part', 'Type', 'Genre', 'LocalOgg', 'LocalMeta', 's3_path_url_44', 's3_path_url_48', 'AudioExists']
|
|
csv << header
|
|
|
|
jam_tracks.each do |jam_track|
|
|
song = jam_track.name
|
|
jam_track.jam_track_tracks.each do |jam_track_track|
|
|
instrument = jam_track_track.instrument_id
|
|
part = jam_track_track.part ? jam_track_track.part : ''
|
|
|
|
|
|
# construct the meta file for this track:
|
|
meta = {}
|
|
meta[:jam_track_id] = jam_track.id
|
|
meta[:track_id] = jam_track_track.id
|
|
meta[:artist] = jam_track.original_artist
|
|
meta[:song] = jam_track.name
|
|
meta[:instrument] = instrument
|
|
meta[:part] = part
|
|
meta[:type] = jam_track_track.track_type
|
|
genre = jam_track.genres.first
|
|
meta[:genre] = genre ? genre.description : ''
|
|
meta[:s3_path_url_44] = "s3://#{private_bucket}/" + jam_track_track.url_44
|
|
meta[:s3_path_url_48] = "s3://#{private_bucket}/" + jam_track_track.url_48
|
|
|
|
meta_json = File.join(tmp_dir, "meta_#{jam_track.id}_#{jam_track_track.id}.json")
|
|
File.open(meta_json, "w") do |f|
|
|
f.write(JSON.pretty_generate(meta))
|
|
end
|
|
|
|
# find the first a-z, 0-9 character and use that
|
|
first_character = song[0].downcase
|
|
folder = File.join(top_folder, first_character)
|
|
if File.exist?(folder) == false
|
|
FileUtils.mkdir_p(folder)
|
|
end
|
|
# folder structure is:
|
|
# audio/a/song-instrument-part-type.ogg
|
|
# audio/a/song-instrument-part-type.ogg.meta
|
|
# run 'part' through a sanitizer to make it filesystem safe
|
|
part = part.gsub(/[^0-9A-Za-z]/, '_')
|
|
base_name = File.join(folder, "#{jam_track.id}_#{jam_track_track.id}_#{instrument}_#{part}_#{jam_track_track.track_type}".downcase)
|
|
ogg_file = "#{base_name}.ogg"
|
|
|
|
exists = s3_manager.exists?(jam_track_track.url_48)
|
|
|
|
|
|
row = []
|
|
row << jam_track.id
|
|
row << jam_track_track.id
|
|
row << jam_track.original_artist
|
|
row << jam_track.name
|
|
row << instrument
|
|
row << part
|
|
row << jam_track_track.track_type
|
|
genre = jam_track.genres.first
|
|
row << (genre ? genre.description : '')
|
|
row << ogg_file.gsub(tmp_dir, '')
|
|
row << ogg_file.gsub(tmp_dir, '') + ".meta"
|
|
row << "s3://#{private_bucket}/" + jam_track_track.url_44
|
|
row << "s3://#{private_bucket}/" + jam_track_track.url_48
|
|
row << exists
|
|
|
|
csv << row
|
|
|
|
|
|
FileUtils.cp(meta_json, "#{ogg_file}.meta")
|
|
# cleanup meta
|
|
FileUtils.rm(meta_json)
|
|
end
|
|
|
|
if max > 0
|
|
max -= 1
|
|
if max == 0
|
|
puts "Max of jamtracks reached"
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
# dump the 1st 10 lines to stdout for quick verification
|
|
File.open(csv_file, "r") do|f|
|
|
10.times do |i|
|
|
puts f.readline
|
|
end
|
|
end
|
|
|
|
s3_manager.upload('jam_track_manifests/manifest.csv', csv_file, content_type: 'text/csv')
|
|
|
|
folder_to_zip = top_folder
|
|
output_tar_path = Dir.mktmpdir
|
|
|
|
output_tar_file = "#{output_tar_path}/archive.tar.gz"
|
|
|
|
safe_output = Shellwords.escape(output_tar_file)
|
|
|
|
# -c = create
|
|
# -z = compress with gzip
|
|
# -f = to a file
|
|
# -P = (Optional, but useful) Preserve absolute paths.
|
|
# By default, 'tar' strips the leading '/' for security.
|
|
# A common pattern is to cd into the parent dir first.
|
|
|
|
# Safer way: cd to the directory to get relative paths
|
|
parent_dir = File.dirname(folder_to_zip)
|
|
folder_name = File.basename(folder_to_zip)
|
|
safe_parent = Shellwords.escape(parent_dir)
|
|
safe_folder_name = Shellwords.escape(folder_name)
|
|
|
|
# This command is safer as it creates the archive with relative paths
|
|
command = "tar -czf #{safe_output} -C #{safe_parent} #{safe_folder_name}"
|
|
success = system(command)
|
|
|
|
if success
|
|
puts "Successfully created tar.gz file."
|
|
else
|
|
puts "Failed to create tar.gz file."
|
|
end
|
|
|
|
|
|
s3_manager.upload('jam_track_manifests/all-tracks.tar.gz', safe_output, content_type: 'application/gzip')
|
|
|
|
puts "tar.gz output=#{safe_output}"
|
|
|
|
puts "tmp_dir=#{tmp_dir}"
|
|
end
|
|
end
|