ipfixer_client 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 902ee4cf6f34557696c5d28b0dcb07d57e6fb858
+  data.tar.gz: feb994876a3e6df61a710265638b0b99a7470efa
+SHA512:
+  metadata.gz: e17e37fc0e074d4b0a6e97316fa6795b46628fed7ca6787e3b20f30fcea6a5126a34d6bf5df1d005811ee66ca44b0ce1d3ff6a24296d3b4755c324acff057002
+  data.tar.gz: 9c6ebaca0fed2c658024a2176bfe8dfae43ab48dce69f63331899be57879a85d67f5e926876e4e80f464dc1e90c050e5ce1147e446586bc64aaef009e21c7694

data/.gitignore

@@ -0,0 +1,3 @@
+*.swp
+pkg/
+.project

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,61 @@
+PATH
+  remote: .
+  specs:
+    ipfixer_client (0.0.2)
+      daemons
+      thor
+      win32-service
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.0.8)
+<<<<<<< HEAD
+=======
+    columnize (0.3.6)
+    daemons (1.1.9)
+    debugger (1.3.0)
+      columnize (>= 0.3.1)
+      debugger-linecache (~> 1.1.1)
+      debugger-ruby_core_source (~> 1.1.7)
+    debugger-linecache (1.1.2)
+      debugger-ruby_core_source (>= 1.1.1)
+    debugger-ruby_core_source (1.1.7)
+>>>>>>> 8732c7e2a3d79b98e2bc87b9a66bbf666c345865
+    diff-lcs (1.1.3)
+    ffi (1.9.0)
+    ffi (1.9.0-x86-mingw32)
+    method_source (0.8.1)
+    pry (0.9.11.4)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    pry (0.9.11.4-x86-mingw32)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+      win32console (~> 1.3)
+    rake (0.9.2)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.2)
+    rspec-expectations (2.12.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.12.2)
+    slop (3.4.3)
+    thor (0.18.1)
+    win32-service (0.8.0)
+      ffi
+    win32console (1.3.2-x86-mingw32)
+
+PLATFORMS
+  ruby
+  x86-mingw32
+
+DEPENDENCIES
+  ipfixer_client!
+  pry
+  rake (= 0.9.2)
+  rspec

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb})
+  watch(%r{^lib/(.+)\.rb})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb') { "spec" }
+end

data/README

@@ -0,0 +1,64 @@
+Ah, the old ipfixer client to be run on a windows machine...
+
+Have you ever wanted to keep track of one or more remote machines?  Yet their IP addresses are always subject to change?  Well this gem is designed to work with the ipfixer_server to store it's latest IP address in a remotely accessible rails application.  
+
+The ipfixer_service runs on windows machines as a service (so it's always running as long as the PC is on, even if you're logged out).  You can view a list of currently running services by right clicking "My Computer" and selecting "manage".  Then go to...
+
+Services and Applications -> Services
+
+And you will see a list of services currently installed on your PC.  Following the below procedure will install a service named "ipfixer_svc"
+
+
+
+==Fresh Install Sequence (~winxp or winvista)==
+
+1)  Install git (just to download)
+http://git-scm.com/download/win
+
+2)  Install ruby 1.9.3 and then devkit (use the tdm devkit for 1.9.x!!)
+http://rubyinstaller.org/downloads/
+
+    
+    rubyinstaller.exe /verysilent /tasks="addtk,assocfiles,modpath"
+
+
+Devkit:  Extract to c:/devkit and then run c:/devkit/msys.bat
+
+
+    $  cd /c/devkit
+    $  ruby dk.rb init; ruby dk.rb install
+
+
+3)  Clone the repo to desired location
+
+    $  cd dev  # make a directory for development...
+    $  git clone https://github.com/TheNotary/ipfixer_client.git
+    $  cd ipfixer_client
+
+4)  Install bundler, and then install the bundle for this gem
+
+    $  gem install ruby-debug19 # due to bugs, do this...
+    # it will fail, but that's fine and allows us to install debugger-linecache thereafter...
+    # maybe it just needs linecache19 and possibly... ruby-debug-base19-0.11.25??
+    $  gem install bundler
+    $  bundle install
+
+
+5)  Install the gem intself
+
+    $  bundle exec rake install
+
+
+6)  Install the windows service (run cmd as admin on vista... win_key -> 'cmd' -> Ctrl+shft+enter)
+
+    $  ipfixer install
+
+It will prompt you to enter: 
+  -An ipfixes server (I'll make the rails generator shortly and put it online)
+  -A port on which your server runs
+  -An optional dynamic dns URL that it will GET when ever it detects an IP change
+  -Someday, a security token that allows you to authenticate with your ipfixer server
+
+A configuration file can be created... at `c:/it/ipfixer/ipfixer.conf`  It can be modified at any time.  
+
+7)  Now start the service using computer management.  (sry, i'm in a rush...)

data/Rakefile

@@ -0,0 +1,25 @@
+require 'bundler'
+include Rake::DSL
+Bundler::GemHelper.install_tasks
+
+require "rspec/core/rake_task" # RSpec 2.0
+
+RSpec::Core::RakeTask.new(:unit) do |spec|
+  #spec.pattern  = 'spec/*/*_spec.rb'
+  spec.pattern = 'spec/unit/*_spec.rb'
+  spec.rspec_opts = ['--backtrace']
+end
+
+RSpec::Core::RakeTask.new(:all) do |spec|
+  spec.pattern = 'spec/*/*_spec.rb'
+  spec.rspec_opts = ['--debug']
+end
+
+# this is for running tests that you've marked current...  eg:  it 'should work', :current => true do
+RSpec::Core::RakeTask.new(:current) do |spec|
+  spec.pattern = 'spec/*/*_spec.rb'
+  spec.rspec_opts = ['--tag current']
+end
+
+
+task :default => :all

data/bin/ipfixer

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+require 'thor'
+require 'ipfixer_client'
+
+class IpfixerClientRunner < Thor
+  default_task :help
+  
+  desc "help", "Explains the gem's usage"
+  def help
+    IpfixerClient.help
+  end
+  
+  desc "install", "Installs the client as a windows service"
+  def install
+    IpfixerClient.install
+  end
+  
+  desc "uninstall", "Uninstalls the windows service"
+  def uninstall
+    IpfixerClient.uninstall
+  end
+  
+  desc "client_svc", "This command should only be used by the windows service which allows the gem to be run"
+  def client_svc
+    IpfixerClient.client_svc
+  end
+  
+  desc "start", "This command will start the service for you.  Before it will work, you must install the service via `ipfixer install`"
+  def start
+    IpfixerClient.start
+  end
+end
+
+IpfixerClientRunner.start

data/change_log

@@ -0,0 +1,21 @@
+==Future version 0.0.?==
+-Allow ipfixer to work on linux and mac machines too!!!
+-Allow ipfixer_svc to cooperate with watchdog_listener for increased remote administration capabilities!
+-Add a command to start the windows service you lazy bum!
+
+==Version 0.0.2==
+Major:
+-Added DEBUG_MODE to the conf
+-Added an optional security_token to the conf
+
+
+Minor:
+-Made it work happily ipfix servers returning a status code of 201 or 200.  
+-Add error handling for when the IP Address isn't returning a valid IP (I think it just mysteriously crashes)
+-Add error/ usability handling if PORT or SERVER isn't specified in the yaml. 
+ 
+
+==version 0.0.1==
+
+Built the app.  This version spans many months, I think even years.  I didn't think about change logs that far back, but am starting to now...  The early version so of 0.0.1 didn't work; the latest version of 0.0.1, worked and was bumpted to version 0.0.2 to give me some practice...
+

data/conf/config.yml

@@ -0,0 +1,25 @@
+########### BASIC ###############
+
+
+target_server: 192.168.0.11
+port: 80
+
+
+
+
+
+########### ADVANCED ###############
+
+# You can change which site you use to lookup your IP address
+ip_lookup_url: http://api.externalip.net/ip/
+
+# Place a url here and it will be run every time your dns changes.  Afraid.org for
+# example will let you change the ddns subdomain via a direct url you can place
+# here...
+# ddns_update_url: http://www.example.com/up_my_ip_stored_on_your_server
+
+ddns_update_url: 
+
+
+# there's also the debug mode, set debug to true to see more output in the log file located at c:\it\logs\ipfixer.log
+# debug: true

data/ipfixer_client.gemspec

@@ -0,0 +1,47 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ipfixer_client/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ipfixer_client"
+  s.version     = IpfixerClient::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["TheNotary"]
+  s.email       = ["no@email.plz"]
+  s.homepage    = ""
+  s.summary     = %q{ This gem is used to keep track of remote infrastructure }
+  s.description = %q{ You install this service on a windows machine, and it will keep it's IP address posted to a rails application specified and also updates subdomain status at afraid.org.  }
+
+  s.rubyforge_project = "ipfixer_client"
+
+  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_dependency 'thor'
+  s.add_dependency 'win32-service' if RUBY_PLATFORM =~ /mingw32/
+  s.add_development_dependency 'win32console' if RUBY_PLATFORM =~ /mingw32/
+  s.add_development_dependency 'wdm' if RUBY_PLATFORM =~ /mingw32/
+  
+  s.add_dependency 'daemons' if RUBY_PLATFORM =~ /linux/
+
+  
+  s.add_development_dependency('rake', '0.9.2')
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'pry'
+  
+  #s.add_development_dependency('rake-compiler', '0.7.9')
+  #s.add_development_dependency('archive-tar-minitar', '0.5.2')  # this might be another secret dependency
+  #s.add_development_dependency('debugger-ruby_core_source', '1.1.3') # dep dep
+  #s.add_development_dependency('ruby_core_source', '0.1.5') # SECRET DEPENDENCY OF LINECACHE!!! MAYBE...
+  #s.add_development_dependency('ruby-debug19') # installing manually, this gem is able to install linecache19 successfully 
+  #s.add_development_dependency('debugger-linecache', '1.1.2') # depdep
+  
+  #s.add_development_dependency('linecache19', '0.5.12') # dep dep, very problematic one...
+  s.add_development_dependency 'debugger' if RUBY_PLATFORM =~ /linux/
+  #s.add_development_dependency 'guard'
+  #s.add_development_dependency 'guard-rspec'
+  
+  #s.add_development_dependency 'autotest'
+end

data/lib/ipfixer_client.rb

@@ -0,0 +1,81 @@
+LOG_FILE = "C:\\it\\logs\\ipfixer.log"
+LOG_FOLDER = File.dirname LOG_FILE
+LONG_DURATION = 1000
+STANDARD_INTERVAL = 500
+DEBUG_MODE = true
+WINDOWS = RUBY_PLATFORM =~ /mingw32/ ? true : false
+LINUX = RUBY_PLATFORM =~ /linux/ ? true : false
+
+SERVICE_NAME = 'ipfixer_svc'
+SERVICE_DESC = 'A service that helps keep track of remote infrastructure.'
+
+
+require 'ipfixer_client/config_stuff'
+require 'ipfixer_client/logger'
+require 'ipfixer_client/net_stuff'
+require 'ipfixer_client/version'
+require 'ipfixer_client/installer.rb'
+require 'ipfixer_client/ipfixer_svc'
+
+
+config = IpfixerClient.get_configuration_settings
+
+# Point this at your hub
+IP_FIXER_HUB = config["target_server"].nil? ? nil : config["target_server"].dup.gsub(/^https?:\/\//, '') # '192.168.1.1'
+PORT = config["port"].nil? ? "80" : config["port"].to_s.dup                                              # "3000"
+IP_LOOKUP_URL = config["ip_lookup_url"].nil? ? nil : config["ip_lookup_url"].dup                         # 'http://automation.whatismyip.com/n09230945.asp'
+DDNS_UPDATE_URL = config["ddns_update_url"].nil? ? nil : config["ddns_update_url"].dup
+SECURITY_TOKEN = config["security_token"].nil? ? nil : config["security_token"].dup
+#DEBUG_MODE = config["debug"].nil? || config["debug"] == false ? false : true
+
+
+module IpfixerClient
+  extend Logger
+  
+  def self.help
+    puts "This is ipfixer_client, a little client... see the docs"
+  end
+  
+  def self.client_svc
+    DemoDaemon.mainloop
+  end
+  
+  def self.install
+    i = Installer.new 
+    i.install 
+  end
+  
+  def self.uninstall
+    i = Installer.new
+    i.uninstall
+  end
+  
+  def self.start
+    if IpfixerClient::Installer.service_installed?
+      puts "We can start"
+      if WINDOWS
+        result = `sc start #{SERVICE_NAME}`
+        puts result
+      elsif LINUX
+        # FIXME:  Write logic
+      end
+    else
+      puts "The service is not yet installed, please run the command `ipfixer install`"
+    end
+  end
+  
+  def self.stop
+    if IpfixerClient::Installer.service_installed?
+      puts "We can stop"
+      if WINDOWS
+        result = `sc stop #{SERVICE_NAME}`
+        puts result
+      elsif LINUX
+        # FIXME:  Write logic
+      end
+    else
+      puts "The service is not yet installed"
+    end
+  end
+  
+end

data/lib/ipfixer_client/config_stuff.rb

@@ -0,0 +1,36 @@
+require 'yaml'
+require 'fileutils'
+
+module IpfixerClient
+  
+  def self.get_configuration_settings(config_file_path = "C:\\it\\ipfixer\\conf\\config.yml")
+    return default_config_settings unless File.exists? config_file_path
+    config_file = get_config_file config_file_path
+    
+    conf_contents = config_file.read
+    
+    begin
+      config = YAML.load_file(config_file)
+    rescue Exception => e
+      File.open(LOG_FILE,'a+'){ |f| f.puts " ***YAML FILE PROBLEM DETECTED, The file was likely malformed... Check on it, or delete it and reinstall."; f.puts e.message }
+      exit!
+    end
+    
+    return config
+  end
+  
+  def self.get_config_file(file_path)
+    if File.exists?(file_path)
+      File.open(file_path, "rb")
+    else
+      StringIO.new('')
+    end
+  end
+  
+  def self.default_config_settings
+    return {'target_server' => "192.168.0.11", 
+      "port" => 80, 
+      "ip_lookup_url" => "http://api.externalip.net/ip/",
+      "security_token" => "secret pass"}
+  end
+end

data/lib/ipfixer_client/installer.rb

@@ -0,0 +1,213 @@
+module IpfixerClient
+  require 'yaml'
+  require 'rubygems'
+  require 'win32/service' if RUBY_PLATFORM =~ /mingw32/
+  require 'rbconfig'
+  require 'fileutils'
+  
+
+  class Installer
+    include Win32 if RUBY_PLATFORM =~ /mingw32/
+    
+    def initialize
+    end
+    
+    def install(service_name = SERVICE_NAME, target_folder = 'c:\it\ipfixer')
+      uninstall(service_name)   #  uninstalls service if it's already installed
+      
+      ruby = get_ruby_interpreter_path
+      gem_path = get_ipfixer_bin_path
+      service_command_line = construct_service_execution_string(ruby, gem_path)
+      
+      config = prompt_for_information
+      
+      create_installation_files(target_folder, config)
+      
+      if WINDOWS   
+        # Create a new service
+        Service.create({
+          :service_name => service_name,
+          :service_type => Service::WIN32_OWN_PROCESS,
+          :description => SERVICE_DESC,
+          :start_type => Service::AUTO_START,
+          :error_control => Service::ERROR_NORMAL,
+          :binary_path_name => service_command_line,
+          :load_order_group => 'Network',
+          :dependencies => ['W32Time','Schedule', 'RpcSs'],
+          :display_name => service_name
+        })
+      elsif LINUX
+        # FIXME:  Add a linux routine
+        
+      end
+      
+      
+      #`sc start ipfixer_svc`
+    end
+    
+    def get_target_folder
+      return ""  # FIXME: logic
+    end
+    
+    def uninstall(service_name = SERVICE_NAME)
+      # stop the service if it's started
+      # stop if service_started? service_name
+      # if the service is marked for deletion, do nothing here
+      #return if service_marked_for_deletion? service_name
+      Service.delete(service_name) if service_installed? service_name if WINDOWS
+      # FIXME:  write linux logic
+    end
+    
+    def start(service_name = SERVICE_NAME)
+      Service.start(service_name)
+    end
+    
+    def stop(service_name = SERVICE_NAME)
+      Service.stop(service_name)
+    end
+    
+    def create_installation_files(target_folder, config = nil)
+      FileUtils.mkdir_p "#{target_folder}/conf"
+      FileUtils.cp "#{get_root_of_gem}/conf/config.yml", "#{target_folder}/conf/config.yml"
+      update_yml_file(target_folder, config)
+    end
+    
+    def get_root_of_gem
+      dir_name = File.dirname(__FILE__)
+      File.expand_path Dir.new("#{dir_name}/../..").path
+    end
+    
+    
+    #private
+    
+    # The finds out where the ruby interpretr is on the system.
+    def get_ruby_interpreter_path
+      File.join(RbConfig::CONFIG["bindir"], RbConfig::CONFIG["ruby_install_name"])
+    end
+    
+    # This is how I get the path of the ipfixer script in the bin/ folder
+    def get_ipfixer_bin_path
+      Gem.bin_path('ipfixer_client', 'ipfixer').gsub(/.ipfixer$/,'')
+    end
+    
+    # this string is the argument for the service
+    # Example: 'c:\Ruby\bin\ruby.exe -C c:\temp ruby_example_service.rb'
+    def construct_service_execution_string(ruby, gem_path)
+      "#{ruby} -C #{gem_path} ipfixer client_svc"
+    end
+    
+    # this method prompts the user for a few pieces of information
+    def prompt_for_information
+      target_server = prompt_for_target_server
+      port = prompt_for_port((target_server =~ /^https:\/\//).nil? ? "80" : "443")
+      ddns_update_url = prompt_for_ddns_url
+      security_token = prompt_for_security_token
+      
+      config = {'target_server' => target_server, 
+        'port' => port, 
+        'ddns_update_url' => ddns_update_url,
+        'security_token' => security_token }
+      return config
+    end
+    
+    def prompt_for_installation_folder
+      puts "Please specify an installation directory, or hit enter for default 'c:\\it\\ipfixer'"
+      input = STDIN.gets.chomp
+
+      if input == ""
+        return 'c:\it\ipfixer'
+      else
+        return input
+      end
+    end
+    
+    def prompt_for_target_server
+      puts "Please specify a target server name"
+      puts "[192.168.0.11]"
+      input = STDIN.gets.chomp
+      
+      if input == ""
+        return nil
+      else
+        return input
+      end
+    end
+    
+    def prompt_for_port(default_port = "80")
+      puts "Please specify a port"
+      puts "[#{default_port}]"
+      input = STDIN.gets.chomp
+      
+      if input == ""
+        return default_port
+      else
+        return input.to_i
+      end
+    end
+    
+    def prompt_for_ddns_url
+      puts "If you have a ddns direct URL to set your IP address, you may specify that now, else hit enter"
+      puts "ex:  www.example.com/ipsetter.php?lkajsdflkjsdf"
+      input = STDIN.gets.chomp
+      
+      if input == ""
+        return nil
+      else
+        return input
+      end
+    end
+    
+    def prompt_for_security_token
+      puts "If you'd like, you can specify a security token that ipfixer will use to authenticate with the ipfixes server"
+      puts "ex:  'secret pass'"
+      input = STDIN.gets.chomp
+      if input == ""
+        "secret pass"
+      else
+        input
+      end
+    end
+    
+    def service_installed?(service_name)
+      if WINDOWS
+        return `sc query #{service_name}` =~ /FAILED 1060/i ? false : true
+      end
+      
+      if LINUX   # FIXME:  write logic
+        return true
+      end
+    end
+    
+    def service_started?(service_name)
+      return `sc query #{service_name} | grep STATE` =~ /STOPPED/i ? false : true if WINDOWS
+      return true if LINUX   # FIXME:  write logic
+    end
+    
+    def service_marked_for_deletion?(service_name)
+      return `sc query #{service_name} | grep STATE` =~ /STOPPED/i ? false : true if WINDOWS
+      return true if LINUX   # FIXME:  write logic
+    end
+    
+    # writes a new yaml file out of the data entered, unless there was no data entered, 
+    # in which case it will leave that yaml file untouched and with full comments....
+    def update_yml_file(target_folder, config)
+      return if config.nil?
+      
+    
+      target_server = config['target_server']
+      port = config['port']
+      ddns_update_url = config['ddns_update_url']
+      require 'pry';binding.pry
+      config = YAML.load_file(target_folder + '/conf/config.yml')  # "C:\\it\\ipfixer\\conf\\config.yml"
+      
+      config['target_server'] = target_server unless target_server.nil?
+      config['port'] = port unless port.nil?
+      config['ddns_update_url'] = ddns_update_url unless ddns_update_url.nil?
+      
+      File.open(target_folder + '/conf/config.yml', "w") {|f| f.write(config.to_yaml) }
+    end
+      
+  end
+  
+  
+end

data/lib/ipfixer_client/ipfixer_svc.rb

@@ -0,0 +1,120 @@
+require 'rubygems'
+require 'win32/daemon' if RUBY_PLATFORM =~ /mingw32/
+require 'daemons' if RUBY_PLATFORM =~ /linux/
+if RUBY_PLATFORM =~ /linux/
+  class Daemon
+    
+  end
+end
+require 'socket'
+require 'net/http' 
+require 'fileutils'
+
+module IpfixerClient
+  include Win32 if RUBY_PLATFORM =~ /mingw32/
+  
+  begin
+    class DemoDaemon < Daemon  # http://stackoverflow.com/questions/163497/running-a-ruby-program-as-a-windows-service
+      
+      def service_main
+        host_name, last_ip = init_service
+
+        while running?
+          current_ip = IpfixerClient.get_ip_address(IP_LOOKUP_URL)
+          handle_invalid_ip(current_ip) and redo if IpfixerClient.invalid_ip?(current_ip)
+          ip_changed = current_ip != last_ip
+          
+          if ip_changed
+            
+            last_ip = handle_ip_change(host_name, current_ip, last_ip)
+            my_logger "got here"
+          else
+            my_logger "#{Time.now}:  No change in IP, #{current_ip}" if DEBUG_MODE
+          end
+          
+          #my_logger "Service is running #{Time.now}:  #{host_name}"
+          sleep STANDARD_INTERVAL
+        end
+      end
+
+      def service_stop
+        File.open(LOG_FILE, "a"){ |f| f.puts "***Service stopped #{Time.now}" }
+        exit!  # the guy I took the code from might have found the exit! command useful... I can't find a use for it.  Wait.. I think it can't stop if you leave it out now...
+      end
+      
+      # Does initialization preparations for the service.  
+      # returns an array of [host_name, '']
+      def init_service
+        handle_missing_specifications and exit! if missing_specifications_detected
+        
+        host_name = Socket.gethostname
+        last_ip = ''
+        [host_name, last_ip]
+      end
+      
+      # To run, the daemon needs to have an IP Lookup address, and
+      # an IP_FIXER_HUB specified in the config.  If those aren't 
+      # found, we need to exit
+      def missing_specifications_detected
+        (IP_FIXER_HUB.nil? || IP_LOOKUP_URL.nil?) ? true : false
+      end
+      
+      def handle_missing_specifications
+        File.open(LOG_FILE,'a+') do |f|
+          f.puts " ***YAML FILE PROBLEM DETECTED, IP_FIXER_HUB or IP_LOOKUP_URL was nil.  You can't run this service with out a server to contact, or a way of looking up your IP: " 
+          f.puts "#{IP_FIXER_HUB} ... #{IP_LOOKUP_URL}" 
+          f.puts "Check your conf file at c:\\it\\ipfixer\\conf\\conf.yml"
+        end
+        true
+      end
+
+      def handle_invalid_ip(current_ip)
+        my_logger "**ERROR:  Recieved an invalid ip."
+        my_logger "  current_ip:  #{current_ip}"
+        sleep STANDARD_INTERVAL
+        true
+      end
+      
+      def handle_ip_change(host_name, current_ip, last_ip)
+        IpfixerClient.tell_ddns_our_new_ip(DDNS_UPDATE_URL) unless DDNS_UPDATE_URL.nil?
+
+        post_result = IpfixerClient.post_ip(host_name, current_ip, SECURITY_TOKEN)
+        if post_result == true
+          last_ip = current_ip
+          my_logger "Successfully posted IP to mother server... #{current_ip}"
+        else
+          handle_failed_ip_post(current_ip, last_ip, post_result)
+        end
+
+        last_ip
+      end
+
+      def handle_failed_ip_post(current_ip, last_ip, post_result)
+        my_logger "ERROR: Problem uploading new IP Address."
+        my_logger "  current_ip: #{current_ip},  last_ip: #{last_ip}, post_result: #{post_result}"
+        sleep LONG_DURATION
+      end
+
+      def return_hello # for testing that funcs with the my_logger works... begging to be removed...
+        my_logger "hello"
+        sleep 1000
+        "hello"
+      end
+
+      def sleep(x) # for stub testing...
+        Kernel.sleep x
+      end
+      
+      def my_logger(text)
+        IpfixerClient.my_logger(text)
+      end
+
+    end
+
+
+  rescue Exception => err
+    File.open(LOG_FILE,'a+'){ |f| f.puts " ***Daemon failure #{Time.now} err=#{err} " }
+    raise
+  end
+
+end

data/lib/ipfixer_client/logger.rb

@@ -0,0 +1,58 @@
+module IpfixerClient
+  
+  def self.my_logger(text)
+    create_the_log_folder if !Dir.exists? LOG_FOLDER
+    File.open(LOG_FILE, "a"){ |f| f.puts text }
+  end
+  
+  def self.create_the_log_folder
+    logs_folder = LOG_FOLDER
+    FileUtils.mkdir_p(logs_folder) unless File.directory?(logs_folder) 
+  end
+    
+  module Logger
+=begin
+    def my_logger(text)
+      create_the_log_folder if !Dir.exists? LOG_FOLDER
+      File.open(LOG_FILE, "a"){ |f| f.puts text }
+    end
+
+    def create_the_log_folder
+      logs_folder = LOG_FOLDER
+      FileUtils.mkdir_p(logs_folder) unless File.directory?(logs_folder) 
+    end
+=end
+
+    # I moved this here so I'd have all debug output in the same file...
+    # But wouldn't it be better to have a module named Dbg.post_ip instead?
+    def dbg_post_ip(host_name, ip, response, body)
+      my_logger "DEBUGGER:  In Post_IP"
+      my_logger "  host_name:  #{host_name}"
+      my_logger "  ip:         #{ip}"
+      my_logger "  Response:  #{response}"
+      my_logger "  Req body:  #{body}"
+    end
+    
+    def dbg_tell_ddns_our_new_ip(code)
+      my_logger "Sent msg to ddns... response code was...#{code}.   #{Time.now}"
+    end
+    
+    def err_getting_ip(ip_lookup_url, message)
+      my_logger "**ERROR:  Something went wrong trying to get current IP Address"
+      my_logger "ip_lookup_url: #{ip_lookup_url}"
+      my_logger "Exception:  #{message}"
+    end
+    
+    def err_tell_ddns_our_new_ip(ddns_update_url)
+      my_logger "Exception occured whil trying to tell_ddns_our_new_ip..."
+      my_logger "Url was #{ddns_update_url}"
+    end
+    
+    def err_ddns_gave_wrong_response_code
+      my_logger "failed to properly tell ddns our new ip..."
+      false
+    end
+  end
+end
+
+

data/lib/ipfixer_client/net_stuff.rb

@@ -0,0 +1,66 @@
+module IpfixerClient
+  # You need to wait 300 seconds before using this function
+  def self.get_ip_address(ip_lookup_url)
+    begin
+      http_response = Net::HTTP.get_response(URI.parse(ip_lookup_url))
+    rescue Exception => e 
+      err_getting_ip(ip_lookup_url, e.message)
+      return "failedToGetAddress"
+    end
+
+    if http_response.code == "200"
+      return http_response.body
+    else
+      return http_response.body + http_response.code # not very ellegant huh...
+    end
+  end
+  
+  # Returns true if the string supplied wasn't actually a valid ip
+  def self.invalid_ip?(ip)
+    is_invalid = (ip =~ /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/).nil? ? true : false
+  end
+  
+  # POST /ipfixes
+  # { "ipfix": { "host":"Host Name", "ip":"192.168.0.1" } }
+  def self.post_ip(host_name, ip, security_token = nil)
+    security_token = security_token.nil? ? "secret pass" : security_token
+    path = '/ipfixes.json'
+  
+    http = Net::HTTP.new(IP_FIXER_HUB, PORT)
+  
+    req = Net::HTTP::Post.new(path)
+    req.content_type = 'application/json'  # specify json
+  
+    json_string = "{ 'ipfix': { 'host': '#{host_name}', 'ip': '#{ip}', 'security_token': '#{security_token}' } }"
+    req.body = json_string.gsub("'", '"')        # json doesn't accept the single quote symbol
+    
+    
+    begin
+      response = http.start {|htp| htp.request(req) }
+    rescue
+      my_logger "FAILURE TO POST TO ADDRESS:  Check if address and port are operational."
+      return false
+    end
+    
+    dbg_post_ip(host_name, ip, response, req.body) if DEBUG_MODE
+    
+    return true if response.code == "200" || response.code == "201"
+    return response.code
+  end
+  
+  def self.tell_ddns_our_new_ip(ddns_update_url)
+    begin
+      http_response = Net::HTTP.get_response(URI.parse(ddns_update_url))
+      dbg_tell_ddns_our_new_ip(http_response.code) if DEBUG_MODE
+    rescue
+      err_tell_ddns_our_new_ip(ddns_update_url)
+    end
+  
+    if http_response.code == "200"
+      true
+    else
+      err_ddns_gave_wrong_response_code
+    end
+  end
+
+end

data/lib/ipfixer_client/version.rb

@@ -0,0 +1,3 @@
+module IpfixerClient
+  VERSION = "0.0.2"
+end

data/spec/acceptance/ipfixer_client_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require 'pry'
+require 'ipfixer_client'
+
+
+describe "IpfixerClient" do
+  
+  it "install should go fine" do
+    # IpfixerClient.install
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'ipfixer_client'
+
+def windows_service_installed?(service_name)
+  response = `sc query #{service_name}` if WINDOWS
+  response = `ps -A |grep ` if LINUX   # FIXME:  Write working linux routine
+  return false if response =~ /FAILED 1060/i if WINDOWS
+  return true
+end
+
+def delete_all_testing_files(target_folder)
+  FileUtils.rm_rf target_folder # if RUBY_PLATFORM =~ /mingw32/
+  # FileUtils.rm_rf target_folder if RUBY_PLATFORM =~ /linux/
+end
+
+def get_project_dir_from_tests
+  File.expand_path Dir.new("#{File.dirname(__FILE__)}/..").path
+end

data/spec/unit/installer_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+require 'fileutils'
+
+describe "installation/ uninstallation" do
+  before :all do
+    @virtual_service_name = "aaa-deleteme-test-service-ipfixer"
+    @target_folder = "/tmp/it/ipfixer"
+    #FileUtils.mkdir_p @target_folder
+    delete_all_testing_files(@target_folder)
+  end
+  after :all do
+    delete_all_testing_files(@target_folder)
+  end
+  
+  
+  before :each do
+    @installer = IpfixerClient::Installer.new
+    @installer.stub!(:prompt_for_target_server).and_return(nil)
+    @installer.stub!(:prompt_for_port).and_return(nil)
+    @installer.stub!(:prompt_for_ddns_url).and_return(nil)
+    @installer.stub!(:prompt_for_security_token).and_return(nil)
+  end
+  
+  after :each do
+    @installer.uninstall @virtual_service_name  # just make sure we don't already have an accidental installation in place
+    
+    @installer.unstub!(:prompt_for_target_server)
+    @installer.unstub!(:prompt_for_port)
+    @installer.unstub!(:prompt_for_ddns_url)
+    @installer.unstub!(:prompt_for_security_token)
+  end
+  
+  
+  it "should install the service into windows and also uninstall it...", :current => true do
+    @installer.install @virtual_service_name, @target_folder
+    windows_service_installed?(@virtual_service_name).should be_true
+
+    @installer.uninstall @virtual_service_name
+    windows_service_installed?(@virtual_service_name).should be_false
+  end
+  
+  it "should setup the log folder and files" do
+    @installer.install @virtual_service_name, @target_folder
+  end
+  
+  it "should be able to launch the daemon loop" do
+    # IpfixerClient.client_svc
+  end
+  
+  it "should be able to find the root of the gem when it's installed" do
+    @installer.get_root_of_gem.should eq(get_project_dir_from_tests)  # this test is a bit silly...
+  end
+  
+  it "should be able to create it's log files" do
+    @installer.create_installation_files(@target_folder)
+    
+    File.exists?(@target_folder+"/conf/config.yml").should be_true
+  end
+  
+  describe "helper methods" do
+    
+    it "should return a valid path" do
+      path = @installer.get_ipfixer_bin_path
+      lambda {
+        FileUtils.cd(path)
+      }.should_not raise_error
+    end
+    
+    
+    describe "when service is uninstalled" do
+      it "should know when the service is not installed" do
+        @installer.service_installed?(@virtual_service_name).should be_false
+      end
+    end
+    
+    describe "when service is installed" do
+      before :each do
+        @installer.install @virtual_service_name, @target_folder
+      end
+      after :each do
+        @installer.uninstall @virtual_service_name
+      end
+      
+      it "should know when the service is installed" do
+        @installer.service_installed?(@virtual_service_name).should be_true
+      end
+      
+      it "should tell us when a service is STOPPED" do
+        @installer.service_started?(@virtual_service_name).should be_false
+      end
+=begin
+      # SOmetimes... this test will fail... it's not predictable...
+      it ".start, .stop, .service_started?" do
+        @installer.start @virtual_service_name
+        @installer.service_started?(@virtual_service_name).should be_true
+        
+        @installer.stop @virtual_service_name
+        # sleep 0.02  # you need to give it a moment to stop...
+        @installer.service_started?(@virtual_service_name).should be_false
+        
+        sleep 0.5  # we need to sleep here so windows services can catch up
+      end
+=end
+      
+    end
+    
+    
+    
+  end
+  
+end

data/spec/unit/ipfixer_svc_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe "IpFixer Svc" do
+  
+  before :each do
+    @d = IpfixerClient::DemoDaemon.new
+    @d.stub!(:sleep).and_return(nil)
+    @d.stub!(:my_logger).and_return(nil)
+  end
+  
+  after :each do
+    @d.unstub!(:sleep)
+    @d.unstub!(:my_logger)
+  end
+  
+  it "should work" do  # for debuging the daemon apparently...
+    @d.return_hello.should eq "hello"
+    # d.service_main  #  only run this once... else it will run for ever and your tests can't pass
+    # binding.pry
+  end
+  
+  it "should handle invalid IPs well" do
+    @d.handle_invalid_ip("i'm invalid").should eq true
+  end
+  
+  it "should initialize the service, yielding the hostname" do
+    a = @d.init_service
+    a.first.should be_an_instance_of(String)
+    a.last.should be_an_instance_of(String)
+    a.length.should eq 2
+  end
+  
+  it "should work" do
+    #binding.pry
+  end
+end

data/spec/unit/net_stuff_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe "net stuff" do
+  before :each do
+    @ip_valid = "192.168.244.244"
+    @ip_with_letters = "192.168.244.24a"
+    @ip_too_big = "192.168.255.2555"
+    @ip_too_short = "1.1.2."
+    @ip_too_many_decimals = "192.168.2.2."
+    @ip_too_few_decimals = "192.168.2444"
+  end
+  
+  describe "reject invalid IP addresses" do
+    it "should reject IP addresses with letters in them" do
+      IpfixerClient.invalid_ip?(@ip_with_letters).should be_true
+    end
+    
+    it "should reject IP addresses that are way too long" do
+      IpfixerClient.invalid_ip?(@ip_too_big).should be_true
+    end
+    
+    it "should reject IP addresses that are way too short" do
+      IpfixerClient.invalid_ip?(@ip_too_short).should be_true
+    end
+    
+    it "should reject IP addresses that have too many decimal points" do
+      IpfixerClient.invalid_ip?(@ip_too_many_decimals).should be_true
+    end
+    
+    it "should reject IP addresses that have too few decimal points" do
+      IpfixerClient.invalid_ip?(@ip_too_few_decimals).should be_true
+    end
+  end
+  
+  it "should accept a valid IP address" do
+    IpfixerClient.invalid_ip?(@ip_valid).should be_false
+  end
+  
+
+  it "should read a config file and return a config object" do
+    #IpfixerClient.get_configuration_settings.should eq true
+  end
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: ipfixer_client
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- TheNotary
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: daemons
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ' You install this service on a windows machine, and it will keep it''s
+  IP address posted to a rails application specified and also updates subdomain status
+  at afraid.org.  '
+email:
+- no@email.plz
+executables:
+- ipfixer
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- README
+- Rakefile
+- bin/ipfixer
+- change_log
+- conf/config.yml
+- ipfixer_client.gemspec
+- lib/ipfixer_client.rb
+- lib/ipfixer_client/config_stuff.rb
+- lib/ipfixer_client/installer.rb
+- lib/ipfixer_client/ipfixer_svc.rb
+- lib/ipfixer_client/logger.rb
+- lib/ipfixer_client/net_stuff.rb
+- lib/ipfixer_client/version.rb
+- spec/acceptance/ipfixer_client_spec.rb
+- spec/spec_helper.rb
+- spec/unit/installer_spec.rb
+- spec/unit/ipfixer_svc_spec.rb
+- spec/unit/net_stuff_spec.rb
+homepage: ''
+licenses: []
+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: ipfixer_client
+rubygems_version: 2.1.8
+signing_key: 
+specification_version: 4
+summary: This gem is used to keep track of remote infrastructure
+test_files: []