Module: KL

Defined in:
lib/kldockeragent.rb,
lib/kldockeragent/net.rb,
lib/kldockeragent/agent.rb,
lib/kldockeragent/helper.rb,
lib/kldockeragent/commands.rb

Defined Under Namespace

Modules: Agent Classes: Api, Notifier, Server

Class Method Summary collapse

Class Method Details

.Command_notifyStatus ⇒ Object 



22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/kldockeragent/commands.rb', line 22

def KL.Command_notifyStatus
	KL.logger.info '[command] Sending instance update...'
	data = KL.prepare_agent_data
	uri = "#{KL.config['notifier']['server']}/api/1.0/nodes/data"
	headers_auth = KL.getAuthorizationHeaders('/api/1.0/nodes/data', data.to_json)
	res = KL.net_post_json(uri, data.to_json, headers_auth)
	if res.is_a?(Net::HTTPSuccess)
		KL.logger.info '[command] Agent notification successfully executed.'
	else
		KL.logger.info '[command] An error has occurred trying to notify update.'
	end
end

.Command_registerNewAgent ⇒ Object 



2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
# File 'lib/kldockeragent/commands.rb', line 2

def KL.Command_registerNewAgent
	KL.logger.info '[command] Registering new agent...'
	agent = KL::Agent.getUUID
	data = KL.prepare_agent_register_data(agent)
	uri = "#{KL.config['notifier']['server']}/api/1.0/nodes/register"
	res = KL.net_post_json(uri, data.to_json)

	if res.is_a?(Net::HTTPSuccess)
		response = JSON.parse(res.body)
		registry = {
			agent: agent,
			server: response['code']
		}
		KL.create_registry_file(registry)
		KL.logger.info '[command] Agent registration has been completed correctly'
	else
		KL.logger.info '[command] An error has occurred trying to register agent.'
	end
end

.config ⇒ Object 



34
35
36
37
38
39
40
 
# File 'lib/kldockeragent/helper.rb', line 34

def KL.config
	configFile = "#{KL.home}/kldockeragent.json"
	KL.create_default_config(configFile, KL.logger) if !File.exist?(configFile)
    config_json = File.read(configFile)
    config_data = JSON.parse(config_json)
    config_data
end

.create_default_config(file, logger) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
 
# File 'lib/kldockeragent/helper.rb', line 6

def KL.create_default_config(file, logger)
	File.open(file, File::RDWR|File::CREAT, 0644) { |f|
		f.flock(File::LOCK_EX)
		value = '{"api":{"port":3344,"ssl":false},"notifier":{"server":"https://hub.kytoonlabs.com:4444","rate":120}}'
		f.rewind
		f.write(value.to_s)
		f.flush
		f.truncate(f.pos)
	}
	logger.info "[config] Default config file has been created at {#{file}}" if logger
end

.create_registry_file(data) ⇒ Object 



65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/kldockeragent/helper.rb', line 65

def KL.create_registry_file(data)
	file = "#{KL.home}/kldockeragent.registry"
	File.open(file, File::RDWR|File::CREAT, 0644) { |f|
		f.flock(File::LOCK_EX)
		f.rewind
		f.write(data.to_json.to_s)
		f.flush
		f.truncate(f.pos)
	}
	logger.info "[config] Registry config file has been created at {#{file}}" if logger
end

.generateHash(url, json_data, private_key) ⇒ Object 



104
105
106
107
108
 
# File 'lib/kldockeragent/helper.rb', line 104

def KL.generateHash(url, json_data, private_key)
	data = "#{url}#{json_data}"
	hash_data = OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha1'), private_key, data)
	hash_data 
end

.getApplicationId ⇒ Object 



82
83
84
85
86
87
88
89
90
 
# File 'lib/kldockeragent/helper.rb', line 82

def KL.getApplicationId
	if (KL.server_registered)
		registry = KL.getRegistryData
		id = registry['agent']
	else
		id = SecureRandom.uuid
	end
	id
end

.getAuthorizationHeaders(url, json_data) ⇒ Object 



92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/kldockeragent/helper.rb', line 92

def KL.getAuthorizationHeaders(url, json_data)
	headers = {}
	if (KL.server_registered)
		registry = KL.getRegistryData
		hash_data = KL.generateHash(url, json_data, registry['agent'])
		auth_code = "#{registry['server']}:#{hash_data}"
		headers = {}
		headers['Authorization'] = auth_code
	end
	headers
end

.getRegistryData ⇒ Object 



77
78
79
80
 
# File 'lib/kldockeragent/helper.rb', line 77

def KL.getRegistryData
	json_reg = JSON.parse(File.open("#{KL.home}/kldockeragent.registry").read)
	json_reg
end

.home ⇒ Object 



29
30
31
32
 
# File 'lib/kldockeragent/helper.rb', line 29

def KL.home
	home = ((Process.euid == 0 and File.directory?('/var')) ? '/var/kldockerpagent' : File.expand_path(Dir.home + '/.kldockeragent'))
	home
end

.logger ⇒ Object 



18
19
20
21
22
23
24
25
26
27
 
# File 'lib/kldockeragent/helper.rb', line 18

def KL.logger
	home = KL.home
	Dir.mkdir(home, 0700) if not File.exist?(home)
	logFile = "#{home}/kldockeragent.log"
	log = WEBrick::Log.new(logFile, WEBrick::BasicLog::INFO ||
	                                     WEBrick::BasicLog::ERROR ||
	                                     WEBrick::BasicLog::FATAL ||
	                                     WEBrick::BasicLog::WARN)
	log
end

.net_post_json(url, data, headers = []) ⇒ Object 



4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
# File 'lib/kldockeragent/net.rb', line 4

def KL.net_post_json(url, data, headers = [])
	KL.logger.info "[net] Posting JSON to #{url} => #{data}"
	
	uri = URI(url)
	
	req = Net::HTTP::Post.new(uri)
	req.content_type = 'application/json'
	req.body = data
	req['X-Kytoonlabs-Docker-Agent'] = KL::Agent.getUUID[0..13].gsub(/\s\w+\s*$/, '')
	headers.each do |key, value|
		req[key] = value
	end

	Net::HTTP.start(uri.hostname, uri.port, :use_ssl => uri.scheme == 'https') do |http|
			 @res = http.request req
	end
	KL.logger.info "[net] Response Code: #{@res.code}, Response Body: #{@res.body}"
	@res
end

.prepare_agent_data ⇒ Object 



110
111
112
113
114
115
116
117
118
 
# File 'lib/kldockeragent/helper.rb', line 110

def KL.prepare_agent_data
	data = {
		system_info: KL.Request_getSystemInfo,
		docker_info: KL.Request_getDockerListAllApplications,
		agent_version: KL::Agent.getVersion
	}
	data

end

.prepare_agent_register_data(hash) ⇒ Object 



53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/kldockeragent/helper.rb', line 53

def KL.prepare_agent_register_data(hash)
	data = {
		private_hash: hash,
		hostname: `hostname`.gsub("\n",""),
		system_info: `uname -a`.gsub("\n",""),
		docker_version: `docker --version`.gsub("\n","").gsub("Docker version ",""),
		agent_version: KL::Agent.getVersion,
		ip_address: IPSocket.getaddress(Socket.gethostname) 
	}
	data
end

.publish_json(json_object, st = 200) ⇒ Object 



48
49
50
51
52
 
# File 'lib/kldockeragent/helper.rb', line 48

def KL.publish_json(json_object, st = 200)
	status st
	content_type :json
	json_object.to_json   
end

.Request_getDockerListAllApplications ⇒ Object 



120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/kldockeragent/helper.rb', line 120

def KL.Request_getDockerListAllApplications
	filter = '_klac'
	apps = Array.new
    query = `docker ps --filter="name=#{filter}" --format="{{.ID}}::{{.Names}}::{{.Status}}::{{.Image}}"`
    query.gsub!(/\r\n?/, "\n")
    query.each_line do |line|
        data = line.split('::')
        apps.push({
        	'id' => data[0], 
        	'name' => data[1].gsub(filter,""),
        	'status'=>data[2],
        	'image'=>data[3].gsub("\n","")
        	})
    end
    return apps
end

.Request_getSystemInfo ⇒ Object 



137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
 
# File 'lib/kldockeragent/helper.rb', line 137

def KL.Request_getSystemInfo
	usw = Usagewatch
	info = {}
	if KL::Agent.is_linux
		info['os'] = 'linux'
		info['diskused'] = usw.uw_diskused.to_s
		info['diskused_perc'] = usw.uw_diskused_perc.to_s
		info['cpuused'] = usw.uw_cpuused.to_s
		info['memused'] = usw.uw_memused.to_s
		#info['cputop'] = usw.uw_cputop
		#info['memtop'] = usw.uw_memtop
	else
		info['os'] = 'not linux'
	end 
	info
end

.server_registered ⇒ Object 



42
43
44
45
46
 
# File 'lib/kldockeragent/helper.rb', line 42

def KL.server_registered
	registryFile = "#{KL.home}/kldockeragent.registry"
	reg = File.exist?(registryFile)
	reg
end