process_controller 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d7675279ad00cea114fbb342f65f39949b86c474
+  data.tar.gz: 89d622bc7dfe864917a94b034c6b910220484452
+SHA512:
+  metadata.gz: 380067bb93500337ed7fe84383d854364fa9d092b965525e5e9bc0cd736949d0be6b80d18d8312cdfbf447e99d6d5601bcf8b16366032cb6e0b78f4704f91049
+  data.tar.gz: 37b3a7510b9009b696dfed81390e8703163fe87f1b9472f68a6e9e1863bd9714aa9b47d9120faec75a11f8f172f450036f44d150c50fcc76e9e731d5b3509c0f

data/.gitignore

@@ -0,0 +1,36 @@
+.idea/
+
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in control.gemspec
+gemspec
+
+

data/README.md

@@ -0,0 +1,2 @@
+# control
+A Gem for stop/start/restart process

data/control.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'control/version'
+
+Gem::Specification.new do |s|
+  s.name          = 'process_controller'
+  s.version       = Control::VERSION
+  s.authors       = ['ohad partuck']
+  s.email         = ['ohadpartuck@gmail.com']
+  s.homepage      = 'http://open-source.com'
+  s.licenses      = ['MIT']
+  s.summary       = %q{stop/start/restart}
+  s.description   = %q{Generic stop/start/restart for processes}
+
+  s.files         = `git ls-files`.split("\n")
+  # s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  # s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_runtime_dependency 'activesupport', '~> 4.2'
+
+end

data/lib/control/version.rb

@@ -0,0 +1,3 @@
+module Control
+  VERSION = '0.0.1'
+end

data/lib/control_helper.rb

@@ -0,0 +1,143 @@
+module ControlHelper
+	extend self
+
+	def find_app_pid(options)
+		pid_filename = options.fetch(Control_P::OPTIONS_ATTRIBUTES[:pid], nil)
+
+		if pid_filename
+			get_pid_from_file(pid_filename)
+		else
+			search_by_string = retreive_search_string(options)
+			find_pid_with_ps(search_by_string)
+		end
+	end
+	
+	def retreive_search_string(options)
+		attributes = Control_P::OPTIONS_ATTRIBUTES
+		find_by = options.fetch(attributes[:find_pid_by], Control_P::FIND_BY_OPTIONS[:app_filename])
+		#TODO validate find_by is in Control_P::FIND_BY_OPTIONS
+		search_string = options.fetch(attributes[find_by], nil)
+		raise "no idea how to search for old pid. find_by is #{find_by}" if search_string.nil?
+
+		search_string
+	end
+
+	def get_pid_from_file(pid_filename)
+		File.open(pid_filename, &:readline).strip
+	end
+	
+
+	def find_pid_with_ps(search_by_string)
+		pid = nil
+		procs = `ps aux`
+
+		procs.each_line do |proc|
+			if proc.include?(search_by_string)
+				res = proc.split(' ')
+				old_pid = res[1]
+				return old_pid.to_i
+			end
+		end
+
+		pid
+	end
+
+	def exit_if_not_running!(options)
+		old_pid = find_app_pid(options)
+		unless app_running?(old_pid)
+			app_name = options.fetch(Control_P::OPTIONS_ATTRIBUTES[:app_name], '')
+
+			p "app #{app_name} is already NOT running"
+			exit(1)
+		end
+
+		old_pid
+	end
+
+	def app_running?(pid)
+		!pid.nil?
+	end
+
+	def start_a_new_process!(options)
+		attributes = Control_P::OPTIONS_ATTRIBUTES
+
+		start_command = options.fetch(attributes[:start_command])
+
+		p "trying to start a new using  start_command: #{start_command}"
+
+		pid = spawn(start_command)
+		Process.detach(pid) if pid
+		sleep 5 # give the new app enough time to crash
+		find_app_pid(options)
+	end
+
+	def exit_if_old_process_is_already_running!(options)
+		p 'checking if there\'s a running process'
+		old_pid = find_app_pid(options)
+		if old_pid
+			p "#{app_name} is already running. old_pid is #{old_pid} exiting"
+			exit(1)
+		end
+	end
+
+	def kill_the_process!(options)
+		kill_command = options.fetch(Control_P::OPTIONS_ATTRIBUTES[:kill_command])
+		`#{kill_command}`
+		false
+	rescue Errno::ESRCH
+		p 'no such process returning true for kill_the_process!'
+		true
+	rescue => e
+		p "error in killing process #{e.inspect}"
+	end
+
+	def restart_the_app!(options)
+		restart_command = options.fetch(Control_P::OPTIONS_ATTRIBUTES[:restart_command])
+		`#{restart_command}`
+	end
+
+	def kill_with_retries!(options)
+		num_tries = 4
+		(1..num_tries).to_a.each do |try|
+			res = kill_the_process!(options)
+			return true if res
+			sleep 5
+			old_pid = find_app_pid(options)
+			if old_pid
+				p "error in kill process #{app_name}. found pid #{old_pid} try number #{try}"
+				exit(1) if try == num_tries
+			else
+				app_name = options.fetch(Control_P::OPTIONS_ATTRIBUTES[:app_name], '')
+				p "#{app_name}, it's dead."
+				return true
+			end
+		end
+	end
+
+	def check_for_success_in_starting_new_process!(options)
+		prefix = "#{Control_P::HOSTNAME}"
+
+		pid = find_app_pid(options)
+		if pid
+			p "#{prefix} Ok, Restarted. new pid #{pid}"
+			exit(0)
+		else
+			p "#{prefix} problem restarting. Check your code. #{pid}"
+			exit(1)
+		end
+	end
+
+	def kill_the_old_process_if_needed(options)
+
+		old_pid = find_app_pid(options)
+		if app_running?(old_pid)
+			# TODO should wait ??
+			kill_with_retries!(options)
+		else
+			app_name = options.fetch(Control_P::OPTIONS_ATTRIBUTES[:app_name], '')
+			p "There's no app up to restart (#{app_name}), Trying to start a new one.."
+			true
+		end
+	end
+
+end

data/lib/process_controller.rb

@@ -0,0 +1,64 @@
+require 'socket'
+require 'control_helper'
+require 'active_support/core_ext/hash/indifferent_access'
+
+class Control_P
+	OPTIONS_ATTRIBUTES = {action: 'action', pid: 'pid_filename', find_pid_by: 'find_pid_by',
+												app_name: 'app_name', port_num: 'port_num', app_filename: 'app_filename',
+												http_server: 'http_server', kill_command: 'kill_command',
+												restart_command: 'restart_command', start_command: 'start_command'}.with_indifferent_access
+
+	FIND_BY_OPTIONS = {app_filename: 'app_filename', port_num: 'port_num', app_name: 'app_name', pid_file: 'pid_file'}.with_indifferent_access
+	HOSTNAME = Socket.gethostname
+
+	# Main Method for all actions
+	def self.do(options)
+		options = options.with_indifferent_access
+		#TODO options validations
+		action 				= options.fetch(OPTIONS_ATTRIBUTES[:action], nil)
+
+		case action
+			when 'start'
+				start_actions(options)
+			when 'stop'
+				stop_actions(options)
+			when 'restart'
+				restart_actions(options)
+			else
+				raise "action #{action} not implemented"
+		end
+	end
+
+	def self.helper
+		ControlHelper
+	end
+
+	def self.restart_actions(options)
+
+		http_server = options.fetch(OPTIONS_ATTRIBUTES[:http_server], false)
+
+		#means it's seamless, just need to send a kill signal and it will restart it self
+		if http_server
+			helper.restart_the_app!(options)
+		else
+			helper.kill_the_old_process_if_needed(options)
+			helper.start_a_new_process!(options)
+		end
+
+		helper.check_for_success_in_starting_new_process!(options)
+	end
+
+	def self.start_actions(options)
+		helper.exit_if_old_process_is_already_running!(options)
+
+		helper.start_a_new_process!(options)
+		helper.check_for_success_in_starting_new_process!(options)
+	end
+
+	def self.stop_actions(options)
+		helper.exit_if_not_running!(options)
+
+		helper.kill_the_process!(options)
+	end
+
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: process_controller
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- ohad partuck
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+description: Generic stop/start/restart for processes
+email:
+- ohadpartuck@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".DS_Store"
+- ".gitignore"
+- Gemfile
+- README.md
+- control.gemspec
+- lib/control/version.rb
+- lib/control_helper.rb
+- lib/process_controller.rb
+homepage: http://open-source.com
+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.4.5
+signing_key: 
+specification_version: 4
+summary: stop/start/restart
+test_files: []