Class: Datapimp::Sync::DropboxFolder

Inherits:
Hashie::Mash
  • Object
show all
Includes:
Logging
Defined in:
lib/datapimp/sync/dropbox_folder.rb

Instance Method Summary collapse

Methods included from Logging

#log, #logger, #logger=

Instance Method Details

#cursor ⇒ Object

The Dropbox Delta API uses a cursor to keep track of the last state the local filesystem has synced with. We store this in the syncable folder itself



87
88
89
 
# File 'lib/datapimp/sync/dropbox_folder.rb', line 87

def cursor
  cursor_path.exist? && cursor_path.read
end

#cursor_path ⇒ Object 



91
92
93
 
# File 'lib/datapimp/sync/dropbox_folder.rb', line 91

def cursor_path
  local_path.join('.dropbox-cursor')
end

#delta ⇒ Object

Provides access to the Dropbox API Delta which will tell us how to modify the state of ‘local_path` to match what exists on Dropbox.



75
76
77
 
# File 'lib/datapimp/sync/dropbox_folder.rb', line 75

def delta
  @delta ||= dropbox.delta(cursor, remote_path)
end

#dropbox ⇒ Object

Provides easy access to the Dropbox client



68
69
70
 
# File 'lib/datapimp/sync/dropbox_folder.rb', line 68

def dropbox
  @dropbox ||= Datapimp::Sync.dropbox
end

#local_path ⇒ Object

A Pointer to the local path we will be syncing with the Dropbox remote



80
81
82
 
# File 'lib/datapimp/sync/dropbox_folder.rb', line 80

def local_path
  Pathname(local)
end

#remote_path ⇒ Object 



95
96
97
98
99
 
# File 'lib/datapimp/sync/dropbox_folder.rb', line 95

def remote_path
  dropbox.ls(remote)
rescue(Dropbox::API::Error::NotFound)
  nil
end

#remote_path_entries ⇒ Object 



112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/datapimp/sync/dropbox_folder.rb', line 112

def remote_path_entries
  pather = lambda do |entry|
    if entry.is_dir
      Array(dropbox.ls(entry.path)).map(&pather)
    else
      entry
    end
  end

  remote_path.map(&pather).flatten
end

#remote_path_missing? ⇒ Boolean

Returns:

  • (Boolean) 


108
109
110
 
# File 'lib/datapimp/sync/dropbox_folder.rb', line 108

def remote_path_missing?
  remote_path.nil?
end

#remote_path_parent ⇒ Object 



101
102
103
104
105
106
 
# File 'lib/datapimp/sync/dropbox_folder.rb', line 101

def remote_path_parent
  parent, _ = File.split(remote)
  dropbox.ls(parent)
rescue(Dropbox::API::Error::NotFound)
  nil
end

#run(action, options = {}) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
 
# File 'lib/datapimp/sync/dropbox_folder.rb', line 5

def run(action, options={})
  action = action.to_sym

  log "DropboxFolder run:#{action}"

  if action == :push
    run_push_action
  elsif action == :pull
    run_pull_action
  elsif action == :create
    run_create_action
  end
end

#run_create_action ⇒ Object 



19
20
21
 
# File 'lib/datapimp/sync/dropbox_folder.rb', line 19

def run_create_action
  dropbox.mkdir(remote)
end

#run_pull_action ⇒ Object 



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/datapimp/sync/dropbox_folder.rb', line 23

def run_pull_action
  binding.pry

  remote_path_entries.each do |entry|
    remote_dropbox_path = entry.path

    log "Syncing #{ remote_dropbox_path }"
    begin
      relative_local_path = remote_dropbox_path.gsub("#{remote}/",'')
      target = local_path.join(relative_local_path)

      next if target.exist? && target.size == entry.bytes

      if entry.is_dir
        log "Creating folder #{ relative_local_path }"
        FileUtils.mkdir_p local_path.join(relative_local_path)
      else
        log "== Syncing #{ entry.path }"
        remote_content = dropbox.download(remote_dropbox_path)
        target.open("w+") {|fh| fh.write(remote_content) }
      end
    rescue => e
      log "== Error while saving #{ remote_dropbox_path } to #{ relative_local_path }"
      log "    * Message: #{ e.message }"
    end
  end
end

#run_push_action ⇒ Object 



51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/datapimp/sync/dropbox_folder.rb', line 51

def run_push_action
  if remote_path_missing?
    run_create_action()
  end

  Dir[local_path.join("**/*")].each do |f|
    f = Pathname(f)
    base = f.relative_path_from(local_path).to_s
    target_path = File.join(remote, base)

    log "Uploading #{ f } to #{target_path}"

    dropbox.upload(target_path, f.read, :overwrite => false)
  end
end