munin2graphite 0.1.0

data/Gemfile

@@ -0,0 +1,19 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+
+gem "rufus-scheduler", "2.0.10"
+gem "daemons", "1.1.4"
+gem "parseconfig"
+gem "munin-ruby", "~> 0.2.1"
+
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "yard", "~> 0.6.0"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Jose Fernandez (magec)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,123 @@
+munin2graphite
+===============
+
+Munin2graphite is a munin-node to graphite translator. It works as a daemon that connects to a [munin-node](http://munin-monitoring.org/wiki/munin-node), and translates the data and the graphics into [carbon/graphite](http://graphite.wikidot.com/).
+
+Installing
+----------
+
+To install munin2graphite you need a working ruby virtual machine with rubygems installed. Once you've got that, It's as easy as
+
+    gem install munin2graphite
+    
+Configuring
+------------
+
+Munin2graphite can be used to post data to graphite from any number of munin nodes you want. The idea is simple, there is bunch of workers that periodically ask for metrics to their munin-nodes and then post that data to carbon. Also, every time the daemon is run, the available graphs from the munin nodes are read, translated and posted into graphite as well.
+
+## Workers
+You can either choose to use workers with different configuration or configure everything as global in the config file. A worker implies a new thread of execution with different configuration. Note that if you don't rewrite a given value on the worker, the one in the global config will be used.
+
+## Config Example
+Imagine, for example, that we have two munin-nodes in two different servers (munin-node1.example.com,munin-node2.example.com). Let's say that one munin node has, in turn 2 nodes configured on it and the other just one (node1.munin-node1.example.com and node2.munin-node1.example.com). We also have one graphite server and one carbon server (carbon.example.com and graphite.example.com), they can be on the same machine on in a different one. A valid config file for this would be:
+
+    # Log config
+    # log: The logfile, STDOUT if stdout is needed
+    # log_level: Either DEBUG, INFO or WARN
+    log=/var/log/munin2graphite
+    log_level=INFO
+    
+    # Carbon backend
+    # This has to point to the carbon backend to submit metrics
+    carbon_hostname=carbon.example.com
+    carbon_port=2003
+    
+    # Graphite endpoint
+    # This is needed to send graph data to graphite
+    graphite_endpoint=http://graphite.example.com/
+    
+    # User and password of the graphite web UI
+    graphite_user=test
+    graphite_password=secret
+
+    # This is the prefix you want the on metrics
+    graphite_metric_prefix=test.server
+    
+    # The prefix you want in the graphics, note that in the UI the grapichs are shown under the user name, so the user name is also added prfixed
+    # to this prefix. That's why conveniently, I used 'test' (the user name) in the metric prefix
+    graphite_graph_prefix=server
+    
+    
+    # The period for sending the metrics
+    # its format is the one of rufus-scheduler    
+    scheduler_metrics_period=1m
+    
+    # The munin node hostname and its port
+    munin_hostname=localhost
+    munin_port=4949
+    
+    # Apart from the global configuration, you can define workers so a new thread is opened with the new configuration,
+    # this is particulary useful when you have a single munin-node with several nodes configured and want to send different graphs
+    # with different prefixes
+    [node1.munin-node1]
+    munin_hostname=munin-node1.example.com
+    nodes=node1
+
+    [node2.munin-node1]
+    munin_hostname=munin-node1.example.com
+    nodes=node2
+    
+    [munin-node2]
+    munin_hostname=munin-node1.example.com
+
+Running it
+-----------
+You can run it either as a daemon or as an executable. To run it as an executable, just call it with the config file. 
+
+    munin2graphite config.conf
+
+There is also a daemon version, bassically the same thing but wrapped up with the daemons gem. Its usage is as follows. By default the config file location will be /etc/munin2graphite/munin2graphite.conf. This daemon also supports to be run from /etc/init.d by means of a symbolic link.
+
+
+    Usage: munin-graphite.rb <command> <options> -- <application options>
+    
+    * where <command> is one of:
+      start         start an instance of the application
+      stop          stop all instances of the application
+      restart       stop all instances and restart them afterwards
+      reload        send a SIGHUP to all instances of the application
+      run           start the application and stay on top
+      zap           set the application to a stopped state
+      status        show status (PID) of application instances
+                  
+    * and where <options> may contain several of the following:
+                  
+      -t, --ontop                      Stay on top (does not daemonize)
+      -f, --force                      Force operation
+      -n, --no_wait                    Do not wait for processes to stop
+                             
+    Common options:
+      -h, --help                       Show this message
+          --version                    Show version
+
+
+Troubleshooting
+-----------------
+You better start testing the conf with the not daemonized mode and then swap to the daemon, another aproarch is to use the daemon but adding a -t (stay on top) when running.
+
+Contributing to munin2graphite
+------------------------------- 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+Copyright
+-----------
+
+Copyright (c) 2011 Jose Fernandez (magec). See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "munin2graphite"
+  gem.homepage = "http://github.com/magec/munin2graphite"
+  gem.license = "MIT"
+  gem.summary = %Q{Allows to post both data and graphic info from munin to graphite (https://launchpad.net/graphite)}
+  gem.description = %Q{This gem will install as a daemon and can be used to connect to a graphite and a carbon backend. It will not only post the data for the metrics but also create graphs into graphite, by means of a translation from munin-node.}
+  gem.email = "jfernandezperez@gmail.com"
+  gem.authors = ["Jose Fernandez (magec)"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/munin2graphite

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__),"..","lib")))
+require 'rubygems'
+require 'munin2graphite'
+
+if ARGV.last && File.stat(ARGV.last)
+  Munin2Graphite::Config.config_file = ARGV.last
+else
+  Munin2Graphite::Config.config_file = "/etc/conf/munin2graphite.conf"
+end
+
+Thread.abort_on_exception = true 
+
+scheduler = Munin2Graphite::Scheduler.new(Munin2Graphite::Config)
+scheduler.start
+scheduler.scheduler.join

data/bin/munin2graphite-daemon

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+### BEGIN INIT INFO
+# Provides: munin2graphite
+# Required-Start: $network $remote_fs $munin-node
+# Required-Stop: $null
+# Default-Start:  3 5
+# Default-Stop:   0 1 2 6
+# Short-Description: Populates carbon agents with munin-node data
+# Description:    munin graphs to graphite servers
+### END INIT INFO
+
+require 'rubygems'        
+require 'daemons'
+
+THIS_FILE = File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__
+
+DAEMON=File.dirname(THIS_FILE)+ "/munin2graphite"
+Daemons.run(DAEMON,{:dir_mode  => :system, :monitor => true})
+

data/conf/munin2graphite.conf.example

@@ -0,0 +1,35 @@
+# Log config
+# log: The logfile, STDOUT if stdout is needed
+# log_level: Either DEBUG, INFO or WARN
+log=/var/log/munin2graphite.log
+log_level=INFO
+
+# Carbon backend
+# This has to point to the carbon backend to submit metrics
+carbon_hostname=localhost 
+carbon_port=2003
+
+# Graphite endpoint
+# This is needed to send graph data to graphite
+graphite_endpoint=http://graphite/
+
+# prefix for the metrics usually, the user name have to be put as a prefix
+graphite_metric_prefix=
+graphite_graph_prefix=
+graphite_user=test
+graphite_password=
+
+# The period for sending the metrics and the graph info
+# its format is the one of rufus-scheduler
+scheduler_metrics_period=1m
+scheduler_graphs_period=10m
+
+# The munin node hostname and its port
+munin_hostname=localhost
+munin_port=4949
+
+# Apart from the global configuration, you can define workers so a new thread is opened with the new configuration,
+# this is particulary useful when you have a single munin-node with several nodes configured and want to send different graphs
+# with different prefixes
+#[test_worker1]
+#munin_hostname=127.0.0.1

data/etc/munin2graphite/munin2graphite.conf.example

@@ -0,0 +1,35 @@
+# Log config
+# log: The logfile, STDOUT if stdout is needed
+# log_level: Either DEBUG, INFO or WARN
+log=/var/log/munin2graphite.log
+log_level=INFO
+
+# Carbon backend
+# This has to point to the carbon backend to submit metrics
+carbon_hostname=
+carbon_port=2003
+
+# Graphite endpoint
+# This is needed to send graph data to graphite
+graphite_endpoint=http://graphite/
+
+# prefix for the metrics usually, the user name have to be put as a prefix
+graphite_metric_prefix=
+graphite_graph_prefix=
+graphite_user=test
+graphite_password=
+
+# The period for sending the metrics and the graph info
+# its format is the one of rufus-scheduler
+scheduler_metrics_period=1m
+scheduler_graphs_period=10m
+
+# The munin node hostname and its port
+munin_hostname=localhost
+munin_port=4949
+
+# Apart from the global configuration, you can define workers so a new thread is opened with the new configuration,
+# this is particulary useful when you have a single munin-node with several nodes configured and want to send different graphs
+# with different prefixes
+#[test_worker1]
+#munin_hostname=127.0.0.1

data/lib/ast_node.rb

@@ -0,0 +1,344 @@
+require 'uri'
+
+class ASTNode
+
+  attr_accessor :properties, :children, :parent , :root_node, :graph_properties
+
+  def default_colors
+    %w(#00CC00 #0066B3 #FF8000 #FFCC00 #330099 #990099 #CCFF00 #FF0000 #808080
+       #008F00 #00487D #B35A00 #B38F00         #6B006B #8FB300 #B30000 #BEBEBE
+       #80FF80 #80C9FF #FFC080 #FFE680 #AA80FF #EE00CC #FF8080
+       #666600 #FFBFFF #00FFCC #CC6699 #999900)
+  end
+
+  def initialize(raw_data)
+    @root_node = nil
+    @raw_data = raw_data
+    @children = []
+    @properties = {'graph_period' => "seconds","category" => "other"}
+    @graph_properties = {}    
+    @graph_properties[:colorList] = default_colors
+    @parent = nil
+  end
+
+  def config=(config)
+    self.properties.merge!(config)
+  end
+
+  def root?
+    @root_node == nil
+  end
+
+  def children_of_class(klass)
+    children.select { |i| i.is_a? klass }
+  end
+  
+  # Add a child to the node
+  def add_child(child)
+    if self.root?
+      child.root_node = self
+    else
+      child.root_node = self.root_node
+    end
+
+    child.parent = self
+    children << child
+  end
+
+  def compile
+    # The compilation is done twice cause there are certain cases where is necessary, a better implementation would control whether this is needed
+    # or not, but given the small impact I just do it twice
+    children.map{|i| i.compile} if children
+    children.map{|i| i.compile} if children
+  end
+  
+  # Returns the FieldDeclaration Nodes
+  def targets
+    children_of_class(FieldDeclarationNode)
+  end
+
+  def process_variables(properties)
+    [:vtitle,:title].each do |key|
+      aux = properties[key]
+      properties[key].scan(/\$\{(.*)\}/).each do 
+        if self.properties.has_key? $1
+          aux.gsub!(/\$\{#{$1}\}/,self.properties[$1])
+        end
+      end if properties[key]
+      properties[key] = aux
+
+    end
+  end
+  
+  # Returns the global properties as url values
+  def properties_to_url
+    
+    # Color List initialization
+    aux_graph_properties = self.graph_properties.clone
+    process_variables(aux_graph_properties)
+    aux_graph_properties[:colorList] = aux_graph_properties[:colorList].join(",") if aux_graph_properties[:colorList]
+
+    # Change of the base stuff
+    if  self.properties[:base]
+      aux_graph_properties[:yMax] = aux_graph_properties[:yMax].to_f / self.properties[:base] 
+      aux_graph_properties[:yMin] = aux_graph_properties[:yMin].to_f / self.properties[:base]
+      aux_graph_properties.delete :yMax 
+      aux_graph_properties.delete :yMin
+    end
+
+    aux = aux_graph_properties.map{|i,j| "#{i}=#{URI.escape(j.to_s.gsub('%','percent'))}"}.join("&")
+    return aux
+  end
+
+  # This returns the url field of the graph after compiling it
+  def url
+    self.compile
+    url = "#{properties[:endpoint]}/render/?width=586&height=308&#{properties_to_url}&target=" + URI.escape(targets.map{|i| i.compile}.compact.join("&target="))
+  end
+
+end
+
+
+class GlobalDeclarationNode < ASTNode
+  def initialize(line)
+    super
+    line =~ /^([\w_]*)\ (.*)/
+    @value = $2
+  end
+end
+
+def string_to_ansi(string)
+  string.unpack("U*").map{|c|c.chr}.join
+end
+
+class GraphTitleGlobalDeclarationNode < GlobalDeclarationNode
+  def compile
+    root_node.graph_properties[:title] = @value
+  end
+end
+
+class GraphVLabelGlobalDeclarationNode < GlobalDeclarationNode
+  def compile
+    root_node.graph_properties[:vtitle] = @value
+  end
+end
+
+class CreateArgsGlobalDeclarationNode < GlobalDeclarationNode
+end
+
+class GraphArgsGlobalDeclarationNode < GlobalDeclarationNode
+  def compile
+    if @raw_data =~ /--base\ (\d+)/
+      self.root_node.properties[:base] = $1.to_i
+    end
+    if @raw_data =~ /.*logarithmic.*/
+      self.root_node.properties[:logarithmic] = true
+    end
+  end
+end
+
+class GraphCategoryGlobalDeclarationNode < GlobalDeclarationNode
+  def compile
+    root_node.properties["category"] = @value
+  end
+end
+
+class GraphInfoGlobalDeclarationNode < GlobalDeclarationNode; end
+class GraphOrderGlobalDeclarationNode < GlobalDeclarationNode; end
+class GraphTotalGlobalDeclarationNode < GlobalDeclarationNode; end
+class GraphScaleGlobalDeclarationNode < GlobalDeclarationNode; end
+class GraphGlobalDeclarationNode < GlobalDeclarationNode; end
+class HostNameGlobalDeclarationNode < GlobalDeclarationNode
+  def compile
+    if @raw_data =~ /host_name (.*)$/
+      root_node.properties['hostname'] = $1
+    end
+  end
+end
+class UpdateGlobalDeclarationNode < GlobalDeclarationNode; end
+class GraphPeriodGlobalDeclarationNode < GlobalDeclarationNode; 
+  def compile
+    if @raw_data =~ /graph_period (.*)$/
+      root_node.properties['graph_period'] = $1
+    end
+  end
+end
+class GraphVTitleGlobalDeclarationNode < GlobalDeclarationNode; end
+class ServiceOrderGlobalDeclarationNode < GlobalDeclarationNode; end
+class GraphWidthGlobalDeclarationNode < GlobalDeclarationNode; end
+class GraphHeightGlobalDeclarationNode < GlobalDeclarationNode; end
+class GraphPrintFormatGlobalDeclarationNode < GlobalDeclarationNode; end
+
+
+class FieldDeclarationNode < ASTNode
+ 
+  def metric
+    "#{root_node.properties['graphite_metric_prefix']}.#{root_node.properties['hostname'].split('.').first}.#{root_node.properties['category']}.#{root_node.properties['metric']}.#{children.first.metric}"
+  end
+
+  def compile
+    aux = children.first.apply_function(metric.gsub("-","_"))
+    children[1..-1].each do |i|
+      aux = i.apply_function(aux)
+    end if children[1..-1]
+    if self.root_node.properties[:logarithmic]
+      # NOT IMPLEMENTED the logarithmic means that a logarithmic scale is to be used not that a log function has to be implemented aux = "log(#{aux},10)"
+    end
+    if self.properties[:stacked]
+      aux = "stacked(#{aux})"
+    end
+    if self.properties[:is_negative]
+      aux = "scale(#{aux},-1)"
+    end
+    if self.properties[:alias]
+      aux =  "alias(#{aux},'#{self.properties[:alias]}')"
+    end
+    if self.properties[:hide]
+      return nil
+    else
+      return aux
+    end
+  end
+
+  def index
+    return parent.children_of_class(FieldDeclarationNode).index(self)
+  end
+
+end
+
+class FieldPropertyNode < ASTNode
+  attr_accessor :metric
+  
+  def initialize(line)
+    super   
+    line =~ /([\w_]+)\.(\w+)\ (.*)$/
+    @metric   = $1
+    @function = $2
+    @value    = $3
+  end
+  
+  def apply_function(operand)
+    return "FUNCION(#{operand})"
+  end
+  
+end
+
+class LabelFieldPropertyNode < FieldPropertyNode; 
+  def apply_function(operand)
+    parent.properties[:alias] = @value
+    return operand
+  end
+end
+
+class ColourFieldPropertyNode < FieldPropertyNode
+  
+  def apply_function(operand)
+    # In this case a function can't be applied cause graphite does not allow this
+    # instead we modify a given
+    aux = @value  
+    aux = "##{@value}"   if @value =~ /[0-9A-Fa-f]{3,6}/
+    
+    self.root_node.graph_properties[:colorList] ||= Array.new
+    self.root_node.graph_properties[:colorList][parent.index] = aux
+    return operand
+  end
+end
+
+class TypeFieldPropertyNode < FieldPropertyNode
+  
+  def apply_function(operand)
+    if @value == "DERIVE" || @value == "COUNTER"
+      # The scaling is because of the minutes/seconds"
+      return "scale(nonNegativeDerivative(#{operand}),0.0166666666666667)"
+    end
+    operand
+  end
+end
+
+class DrawFieldPropertyNode < FieldPropertyNode
+  def apply_function(operand)
+    if @value == "STACK" || @value == "AREA"
+      parent.properties[:stacked] = true
+    end
+    return operand
+  end
+end
+
+
+class MinFieldPropertyNode < FieldPropertyNode
+  def apply_function(operand)
+    self.root_node.graph_properties[:yMin] ||= @value.to_i
+    self.root_node.graph_properties[:yMin] = @value.to_i if  self.root_node.graph_properties[:yMin] > @value.to_i 
+    return operand
+  end
+end
+
+class MaxFieldPropertyNode < FieldPropertyNode
+  def apply_function(operand)
+    self.root_node.graph_properties[:yMax] ||= @value.to_i
+    self.root_node.graph_properties[:yMax] = @value.to_i if  self.root_node.graph_properties[:yMax] < @value.to_i 
+    return operand
+  end
+end
+
+class InfoFieldPropertyNode < FieldPropertyNode
+  def apply_function(operand)
+   # puts "Info tag is currently ignored"
+    return operand
+  end
+end
+
+class WarningFieldPropertyNode < FieldPropertyNode
+  # Ignored
+  def apply_function(operand)
+    operand
+  end
+end
+
+class CriticalFieldPropertyNode < FieldPropertyNode
+  # Ignored
+  def apply_function(operand)
+    operand
+  end
+end
+
+
+class CDefFieldPropertyNode < FieldPropertyNode
+  def apply_function(operand)
+    if @raw_data =~ /(\w+),(\d+),\*/      
+      return "scale(#{operand},#{$2})"
+    elsif @raw_data =~ /(\w+),(\d+),\//      
+      return "scale(#{operand},#{1.0/$2.to_i})"
+    end
+    "FUNCTION(#{operand})"
+  end
+end
+
+class GraphFieldPropertyNode < FieldPropertyNode
+  def apply_function(operand)
+    operand
+  end
+end
+
+class ExtInfoFieldPropertyNode < FieldPropertyNode; end
+class NegativeFieldPropertyNode < FieldPropertyNode
+  def apply_function(operand)
+    # We have to mark the other node as negative (note that for this to work we have to compile twice
+    node = self.root_node.targets.find { |i| i.properties[:field_name] == @value }
+    if node
+      node.properties[:is_negative] = true 
+      # We also use the same color
+#      config.log.info("Begin getting metrics negative (node : #{node.index} with : #{parent.index} parent Color = root_node.graph_properties[:colorList][parent.index] ")
+
+      root_node.graph_properties[:colorList][node.index] = root_node.graph_properties[:colorList][parent.index] if root_node.graph_properties[:colorList][parent.index]
+    end
+    return operand
+  end
+end
+
+class SkipDrawFieldPropertyNode < FieldPropertyNode; end
+class SumFieldPropertyNode < FieldPropertyNode; end
+class StackFieldPropertyNode < FieldPropertyNode; end
+class LineValueFieldPropertyNode < FieldPropertyNode; end
+class OldNameFieldPropertyNode < FieldPropertyNode; end
+class ValueFieldPropertyNode < FieldPropertyNode; end

data/lib/carbon.rb

@@ -0,0 +1,36 @@
+require 'socket'
+#
+# Author:: Adam Jacob (<adam@hjksolutions.com>)
+# Copyright:: Copyright (c) 2008 HJK Solutions, LLC
+# License:: GNU General Public License version 2 or later
+#
+# This program and entire repository is free software; you can
+# redistribute it and/or modify it under the terms of the GNU
+# General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+class Carbon
+  def initialize(chost='localhost', port=2003)
+    @carbon = TCPSocket.new(chost, port)
+  end
+  
+  def send(msg)
+    @carbon.write(msg)
+  end
+  
+  def flush
+    @carbon.flush
+  end
+  def close
+    @carbon.close
+  end
+end