Class: Filbunke::Daemon

Inherits:
Object
  • Object
show all
Defined in:
lib/filbunke/daemon.rb

Instance Method Summary collapse

Constructor Details

#initialize(config, local = false) ⇒ Daemon

Returns a new instance of Daemon.



4
5
6
7
8
9
 
# File 'lib/filbunke/daemon.rb', line 4

def initialize(config, local = false)
  @config = config
  @clients = []
  setup_clients!(local)
  write_pid!(config["pid_file"]) unless local
end

Instance Method Details

#run! ⇒ Object 



75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/filbunke/daemon.rb', line 75

def run!
  version = ::File.read(::File.expand_path(::File.join(::File.dirname(__FILE__), "../../VERSION"))).chomp
  @logger.log("Starting filbunked version #{version}")
  counter = 0
  while true
    counter++
    begin
      @clients.each do |client|
        if(counter % client.run_every == 0)
          new_checkpoint = client.update_files!(checkpoint_for_repository(client.repository))
          update_checkpoint_for_repository(client.repository, new_checkpoint)
        end
      end
    rescue StandardError => e
      @logger.log("Died.. #{e.message}")
      @logger.log(e.backtrace.join("\n"))
      exit 1
    end
    sleep 1
  end
end

#setup_clients!(local = false) ⇒ Object 



11
12
13
14
15
16
17
18
19
20
 
# File 'lib/filbunke/daemon.rb', line 11

def setup_clients!(local = false)
  @logger = Logger.new(@config["log_file"], local)
  @logger.log("Initializing filbunked")

  if(@config["version"] && @config["version"].to_i == 2)
    version_2_configure
  else
    version_1_configure
  end
end

#version_1_configure ⇒ Object 



49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/filbunke/daemon.rb', line 49

def version_1_configure
  @config["repositories"].each do |repository_name, repository_config|
    @logger.log("Initializing repository: #{repository_name}")
    @clients << begin
      repository = Repository.new(repository_config["filbunke_server_repository"],
                                  repository_config["filbunke_server_host"],
                                  repository_config["filbunke_server_port"],
                                  repository_config["local_path"],
                                  repository_config["file_umask"].to_i,
                                  repository_config["directory_umask"].to_i,
                                  repository_config["file_url_username"],
                                  repository_config["file_url_password"],
                                  repository_config["hadoop_binary"])
      callbacks = []
      repository_config["callbacks"].each do |callback_name, callback_config|
        require ::File.join(@config["callback_path"], callback_name.to_s)
        callback_class =  Module.const_get(callback_name.split("_").map(&:capitalize).join)
        callbacks << callback_class.new(@logger, callback_config)
      end
      Client.new(repository, @logger, @config["run_every"].to_i, callbacks)
    end
  end
end

#version_2_configure ⇒ Object 



22
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
 
# File 'lib/filbunke/daemon.rb', line 22

def version_2_configure
  @config["repositories"].each do |repository_name, local_repository_config|
    @logger.log("Initializing repository (version 2): #{repository_name}")
    repository_file = File.read("#{repository_name}.yml")
    static_repository_config = YAML.load("#{@config["repository_files_path"]}#{repository_file}")
    @clients << begin
      repository = Repository.new(static_repository_config["filbunke_server_repository"],
                                  static_repository_config["filbunke_server_host"],
                                  static_repository_config["filbunke_server_port"],
                                  local_repository_config["local_path"],
                                  @config["file_umask"].to_i,
                                  @config["directory_umask"].to_i,
                                  static_repository_config["file_url_username"],
                                  static_repository_config["file_url_password"],
                                  @config["hadoop_binary"])
      callbacks = []
      local_repository_config["callbacks"].each do |callback_name, callback_config|
        require ::File.join(@config["callback_path"], callback_name.to_s)
        callback_class =  Module.const_get(callback_name.split("_").map(&:capitalize).join)
        callbacks << callback_class.new(@logger, callback_config)
      end if local_repository_config["callbacks"]
      run_every = local_repository_config["run_every"] ? local_repository_config["run_every"].to_i : @config["run_every"].to_i
      Client.new(repository, @logger, run_every, callbacks)
    end
  end
end