kldockeragent 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8c505ae9e35342dd34f178dec5018675e204693b
+  data.tar.gz: 3853d4786fe5aadf6f631cd5cc461b7c8c5a27ee
+SHA512:
+  metadata.gz: 2854427e5768d19dfc27896c8dea49745f81420479cc0ac7cb18003f1a831b2a63d9cb6fd2180df41fc0450274aeb6d441db43503512bb92b469af519f83e411
+  data.tar.gz: 652d7b08dbe57af4e2f0e272937eed0b29a9c6a80eb07669359a6082ed8b844fbaf70c1f481ce2f5cd45d73290cf9f77bf6fb137dcc82201113fad79bcf5421e

data/.gitignore

@@ -0,0 +1,2 @@
+config/server-registry.json
+*.gem

data/VERSION

@@ -0,0 +1 @@
+0.5.0

data/bin/kldockeragent

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/kldockeragent'
+
+def version?
+	File.read(File.dirname(__FILE__) + '/../VERSION').strip
+end
+
+opts = Trollop::options do
+	version "kldockeragent #{version?} (c) 2016 Kytoonlabs"
+	banner <<-EOS
+Agent for KL Docker Agent configuration management tool.
+Usage:
+       kldockeragent [options]
+
+where [options] are:
+EOS
+	opt :start, "Start the agent. If --daemon option is set true, then the agent will start as a daemon.", :short => '-s'
+	opt :stop, "Stop the daemon agent.", :short => '-t'
+	opt :restart, "Restart the daemon agent.", :short => '-r'
+	opt :status, "Print the status of the daemon agent.", :short => '-a'
+end
+
+if opts[:start]
+	if not KL::Agent.pid.nil?
+		puts "Agent is already running with PID #{KL::Agent.pid}"
+	else
+		opts[:daemon] = true
+		KL::Agent.start(opts)
+	end
+elsif opts[:stop]
+	KL::Agent.stop(opts)
+elsif opts[:restart]
+	KL.logger.info '[main] Restart Agent command detected.'
+	opts[:daemon] = true
+	KL::Agent.stop if KL::Agent.pid.to_i > 0
+	KL::Agent.start(opts)
+elsif opts[:status]
+	KL::Agent.status
+end
+

data/kldockeragent.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name        = 'kldockeragent'
+  s.version     = File.read(File.dirname(__FILE__) + '/VERSION').strip
+  s.date        = File.mtime(File.dirname(__FILE__) + '/VERSION').strftime("%Y-%m-%d")
+  s.summary     = "KL DockerAgent"
+  s.description = "Agent with REST Api to send information about docker containers"
+  s.authors     = ["Kytoonlabs"]
+  s.email       = 'admin@kytoonlabs.com'
+  s.homepage    = 'https://kytoonlabs.com/tools/docker-agent'
+  s.license       = 'MIT'
+  s.require_paths = ['lib']
+  s.executables  << 'kldockeragent'
+  s.files     = `git ls-files`.split("\n").select { |n| !(n =~ /^(modules|test)\/.*/) }
+end

data/lib/kldockeragent/agent.rb

@@ -0,0 +1,151 @@
+require 'rubygems'
+require 'thread'
+require 'uri'
+require 'net/http'
+require 'logger'
+require 'json'
+require 'digest/md5'
+require 'shellwords'
+require 'trollop'
+require 'socket'
+
+module KL
+	module Agent
+		
+		PIDFile = "#{KL.home}/kldockeragent.pid"
+
+		@@notifier_engine = KL::Notifier.new
+		@@web_server = KL::Server.new
+
+		@@global_app_uuid = KL.getApplicationId
+
+		# Start the agent.
+		#
+		# options:
+		#	:daemon   => true if running as a daemon, false if as a console application
+		#	:port     => port of web server will listen to
+		#	:ssl      => set true to enable HTTPS
+		#	:certfile => certificate file path for HTTPS
+		#	:keyfile  => key file path for HTTPS
+		#
+		def self.start(opts={})
+			KL.logger.info "[main] Starting agent: #{KL::Agent.getUUID}"
+			puts "Starting agent..."
+
+			@@config = opts
+
+			Process.daemon if opts[:daemon] and not opts[:mock]
+			begin
+			 	if not is_windows
+					# trap signal
+					['INT', 'KILL', 'HUP'].each do |signal|
+						trap(signal) {
+							KL.logger.info "[main] Shutting down services..."
+							web_server.stop
+							notifier_engine.stop
+							loop do
+								break if notifier_engine.status == :stopped
+								sleep 1
+							end
+
+							self.close
+						}
+					end
+				end
+
+			 	File.open(PIDFile, 'w', 0644) { |f| f.write($$.to_s) }
+
+			 	notifier_engine.start
+			 	web_server.start
+
+			 	@@main_enabled = true
+			 	while @@main_enabled; end
+
+			rescue Exception => e
+			 	KL.logger.error "Starting the agent [Failed] #{e}\n#{e.backtrace.join("\n")}"
+			 	raise e
+			end
+		end
+
+		# Stop the agent's daemon.
+		#
+		def self.stop(opts={})
+			 begin
+			 	pid = File.read(PIDFile).to_i
+			 	puts "Stopping agent with PID #{pid}..."
+			 	Process.kill 'HUP', pid
+
+				if not opts[:mock]
+					begin
+						sleep (KL::Notifier::SleepTime + 0.5)
+
+						Process.kill 0, pid
+						KL.logger.info "[main] Agent is still running."
+						puts "Agent is still running."
+
+						KL.logger.info "[main] Killing agent."
+						puts "Killing agent."
+						Process.kill 9, pid
+					rescue
+						KL.logger.info "[main] Agent has stopped."
+						puts "Agent has stopped."
+						File.delete(PIDFile) if File.exist?(PIDFile)
+					end
+				end
+
+			 rescue
+			 	puts "Agent is not running."
+			 	File.delete(PIDFile) if File.exist?(PIDFile)
+			 end
+		end
+
+		def self.pid
+			begin
+				pid = File.read(PIDFile).to_i
+				return pid if Process.kill 0, pid
+			rescue
+			end
+			nil
+		end
+
+		# Return agent's PID if it is running, otherwise nil.
+		#
+		def self.status
+			if pid.nil?
+				puts "Agent is not running."
+			else
+				puts "Agent is running with PID #{pid}"
+			end
+		end
+
+		def self.is_windows
+			(RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
+		end
+
+		def self.is_linux
+			(RbConfig::CONFIG['host_os'] =~ /linux/)
+		end
+
+		def self.notifier_engine
+			@@notifier_engine
+		end
+
+		def self.web_server
+			@@web_server
+		end
+
+		def self.close
+			KL.logger.info "[main] Stopping agent..."
+		 	@@main_enabled = false
+		end
+
+		def self.getUUID
+			@@global_app_uuid
+		end
+
+		def self.getVersion
+			File.read(File.dirname(__FILE__) + '/../../VERSION').strip
+		end
+
+	end
+end

data/lib/kldockeragent/api.rb

@@ -0,0 +1,51 @@
+require 'sinatra'
+require 'webrick'
+require 'webrick/https'
+require 'webrick/ssl'
+require 'openssl'
+require 'json'
+
+class KL::Api < Sinatra::Base
+
+	before do
+		halt 503 if !KL.server_registered
+		pass if ['ping'].include? request.path_info.split('/')[1]
+		if env['HTTP_AUTHORIZATION'] && env['HTTP_AUTHORIZATION'].split(':').length == 2
+	    	auth_header = env['HTTP_AUTHORIZATION'].split(':')
+	  	else
+	    	halt 401
+	    end
+	    public_key  = auth_header[0]
+	    signature   = auth_header[1]
+
+	    registry = KL.getRegistryData
+
+	    halt 403 if public_key != registry['server']
+
+	    data = request.path
+		data = "#{data}?#{request.query_string}" if request.query_string != ""
+
+		if ['POST', 'PUT', 'PATCH'].include? request.request_method
+			request.body.rewind
+			data += request.body.read
+		end
+
+		computed_signature = OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha1'), registry['agent'], data)
+		if computed_signature == signature
+			KL.logger.info "[api] #{request.request_method} #{request.path}"
+			pass
+		else
+			halt 403
+		end
+	end
+
+	get '/ping' do
+		KL.logger.info "[api] Pong! to #{request.ip}"
+	   'Pong: ' + `date`
+	end
+
+	get '/api/v1/applications' do
+		KL.publish_json(KL.Request_getDockerListAllApplications)
+	end
+end 
+

data/lib/kldockeragent/commands.rb

@@ -0,0 +1,34 @@
+module KL
+	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
+
+	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
+end

data/lib/kldockeragent/helper.rb

@@ -0,0 +1,154 @@
+require 'webrick'
+require 'webrick/https'
+require 'usagewatch'
+
+module KL
+	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
+
+	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
+
+	def KL.home
+		home = ((Process.euid == 0 and File.directory?('/var')) ? '/var/kldockerpagent' : File.expand_path(Dir.home + '/.kldockeragent'))
+		home
+	end
+
+	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
+
+	def KL.server_registered
+		registryFile = "#{KL.home}/kldockeragent.registry"
+		reg = File.exist?(registryFile)
+		reg
+	end
+
+	def KL.publish_json(json_object, st = 200)
+		status st
+		content_type :json
+		json_object.to_json   
+	end
+	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
+
+	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
+
+	def KL.getRegistryData
+		json_reg = JSON.parse(File.open("#{KL.home}/kldockeragent.registry").read)
+		json_reg
+	end
+
+	def KL.getApplicationId
+		if (KL.server_registered)
+			registry = KL.getRegistryData
+			id = registry['agent']
+		else
+			id = SecureRandom.uuid
+		end
+		id
+	end
+
+	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
+
+	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
+
+	def KL.prepare_agent_data
+		data = {
+			system_info: KL.Request_getSystemInfo,
+			docker_info: KL.Request_getDockerListAllApplications,
+			agent_version: KL::Agent.getVersion
+		}
+		data
+
+	end
+
+	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
+
+	def KL.Request_getSystemInfo
+		usw = Usagewatch
+		info = {}
+		if KL::Agent.is_linux
+			info['os'] = 'linux'
+			info['diskused'] = usw.uw_diskused
+			info['diskused_perc'] = usw.uw_diskused_perc
+			info['cpuused'] = usw.uw_cpuused
+			info['memused'] = usw.uw_memused
+			info['cputop'] = usw.uw_cputop
+			info['memtop'] = usw.uw_memtop
+		else
+			info['os'] = 'not linux'
+		end 
+		info
+	end
+
+end

data/lib/kldockeragent/net.rb

@@ -0,0 +1,23 @@
+require 'net/http'
+
+module KL
+	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
+end

data/lib/kldockeragent/notifier.rb

@@ -0,0 +1,106 @@
+require 'thread'
+
+class KL::Notifier
+
+	SleepTime = 10
+
+    NotifierLockFile = "#{KL.home}/notifier.lock.#{Time.now.to_i}"
+
+    attr_reader :enabled, :status, :mode
+
+    def initialize(p={})
+		@lock = Mutex.new
+		@enabled = false
+		@status = :stopped
+		@index = 0
+		config = KL.config
+		@rate = config['notifier']['rate']
+	end
+
+	def stop
+		@enabled = false
+	end
+
+	def start
+		@enabled = true
+		@lock.synchronize {
+			return if @status == :running
+			@status = :running
+		}
+		Thread.new {
+			begin
+				register_notifier_thread(:reset)
+
+				system("rm -f #{KL.home}/operator.*.lock")
+				system("rm -f #{KL.home}/notifier.lock.*")
+
+				KL.logger.info "[notifier] Notifier engine is running"
+
+				self.run_notifier
+
+				File.delete(NotifierLockFile) if File.exist?(NotifierLockFile)
+				KL.logger.info "[notifier] Notifier engine has stopped."
+			
+			rescue Exception => exp
+				KL.logger.error "Cannot start notifier engine => #{exp}\n#{exp.backtrace.join("\n")}"
+			end
+			@status = :stopped
+		}
+	end
+
+	def run_notifier
+		KL.logger.info "[notifier] Executing notifier engine every #{@rate} seconds"
+		while @enabled
+			begin
+				wait_for_notifier?
+
+				notify_data
+
+				sleep SleepTime
+				
+			rescue Exception => e
+				KL.logger.error "Error on executing notifier \n#{e}\n#{e.backtrace.join("\n")}"
+				sleep SleepTime
+			end
+		end
+	end
+
+	def register_notifier_thread(mode=nil)
+		File.open(NotifierLockFile, File::RDWR|File::CREAT, 0644) { |f|
+			f.flock(File::LOCK_EX)
+			value = (mode == :reset ? 0 : (f.read.to_i + 1))
+			f.rewind
+			f.write(value.to_s)
+			f.flush
+			f.truncate(f.pos)
+		}
+	end
+
+	def wait_for_notifier?
+		total_notifier = 1
+		loop do
+			total_notifier = (File.exist?(NotifierLockFile) ? File.read(NotifierLockFile).to_i : 0)
+			return if total_notifier <= 0 or not @enabled
+			sleep 1
+		end
+	end
+
+	def notify_data
+		KL.logger.info "[heartbeat]"
+		if KL.server_registered
+			if (@index <= (@rate/SleepTime))
+				@index = @index + 1
+			else
+				@index = 0
+				KL.logger.info "[notifier] Executing notifier..."
+				KL.Command_notifyStatus
+				KL.logger.info "[notifier] Notifier executed."
+			end
+		else
+			KL.logger.info "[notifier] Executing notifier..."
+			KL.Command_registerNewAgent
+			KL.logger.info "[notifier] Notifier executed."
+		end
+	end
+
+end

data/lib/kldockeragent/server.rb

@@ -0,0 +1,43 @@
+require 'webrick'
+require 'webrick/https'
+require 'openssl'
+require 'rack/ssl'
+
+class KL::Server
+	def initialize
+		@config = KL.config
+		if @config['api']['ssl']
+			options = {
+			    :Port               => @config['api']['port'],
+			    :SSLEnable          => true,
+			    :SSLVerifyClient    => OpenSSL::SSL::VERIFY_NONE,
+			    :SSLCertificate     => OpenSSL::X509::Certificate.new(File.open(@config['api']['cert']['crt']).read),
+			    :SSLPrivateKey      => OpenSSL::PKey::RSA.new(File.open(@config['api']['cert']['key']).read),
+			    :SSLCertName        => [[ "CN", WEBrick::Utils::getservername ]]
+			}
+		else
+			options = {
+			    :Port               => @config['api']['port'],
+			    :SSLEnable          => false
+			}
+		end
+		@webrick_options = options
+		@server = ::Rack::Handler::WEBrick
+	end
+	def start
+		KL.logger.info '[server] Starting web server...'
+		Thread.new {
+			@server.run KL::Api, @webrick_options
+		}
+		if (@config['api']['ssl'])
+			msg = "[server] Web server listening on #{@config['api']['port']} with SSL"
+		else
+			msg = "[server] Web server listening on #{@config['api']['port']}"
+		end
+ 		KL.logger.info msg
+	end
+	def stop
+		@server.shutdown
+		KL.logger.info '[server] Web server has stopped.'
+	end
+end

data/lib/kldockeragent.rb

@@ -0,0 +1,17 @@
+# external dependencies
+require 'rubygems'
+require 'json'
+
+module KL
+end
+
+# internal dependencies
+libdir = File.expand_path(File.dirname(__FILE__))
+
+require libdir + '/kldockeragent/net.rb'
+require libdir + '/kldockeragent/commands.rb'
+require libdir + '/kldockeragent/helper.rb'
+require libdir + '/kldockeragent/api.rb'
+require libdir + '/kldockeragent/server.rb'
+require libdir + '/kldockeragent/notifier.rb'
+require libdir + '/kldockeragent/agent.rb'

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: kldockeragent
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Kytoonlabs
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-11 00:00:00.000000000 Z
+dependencies: []
+description: Agent with REST Api to send information about docker containers
+email: admin@kytoonlabs.com
+executables:
+- kldockeragent
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Rakefile
+- VERSION
+- bin/kldockeragent
+- kldockeragent.gemspec
+- lib/kldockeragent.rb
+- lib/kldockeragent/agent.rb
+- lib/kldockeragent/api.rb
+- lib/kldockeragent/commands.rb
+- lib/kldockeragent/helper.rb
+- lib/kldockeragent/net.rb
+- lib/kldockeragent/notifier.rb
+- lib/kldockeragent/server.rb
+homepage: https://kytoonlabs.com/tools/docker-agent
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14.1
+signing_key: 
+specification_version: 4
+summary: KL DockerAgent
+test_files: []