fenris 0.0.1 → 0.0.2

data/lib/fenris/client.rb

@@ -1,9 +1,16 @@
 require 'restclient'
 require 'json'
 require 'openssl'
+require 'uri'
+require 'eventmachine'
 
 module Fenris
   class Client
+    def initialize(url)
+      @url = url
+      @url = URI.parse(url) unless url.is_a? URI
+    end
+
     def debug(message)
       puts "DEBUG: #{message}" if ENV['DEBUG']
     end
@@ -12,24 +19,49 @@ module Fenris
       puts "LOG: #{message}"
     end
 
-    def initialize(url)
-      @url = url
-    end
-
-    def update(ip, port)
-      RestClient.put("#{@url}", { :ip => ip, :port => port }, :content_type => :json, :accept => :json)
+    def update(location)
+      RestClient.put("#{@url}", { :location => location }, :content_type => :json, :accept => :json)
     end
   
     def user
       @user ||= JSON.parse RestClient.get("#{@url}", :content_type => :json, :accept => :json)
     end
 
+    def ssl?
+      @url.scheme == "https"
+    end
+
+    def async_connection
+      @async_connection = nil if @async_connection && @async_connection.error?
+      @async_connection ||= EM::Protocols::HttpClient2.connect :host => @url.host, :port => @url.port, :ssl => ssl?
+    end
+
+    def auth_string
+      "Basic " + ["#{@url.user}:#{@url.password}"].pack('m').strip.gsub(/\n/,'')
+    end
+
+    def async_update(&blk)
+      request = async_connection.get(:uri => "/", :authorization => auth_string )
+      request.callback do |response|
+        if response.status == 200
+          # TODO - output if something has changed
+          @broker ||= OpenSSL::X509::Certificate.new(async_connection.get_peer_cert) if ssl?
+          @user = JSON.parse response.content
+        else
+          log "Error updating user info"
+          debug response.status
+          @async_connection = nil
+        end
+        blk.call if blk
+      end
+    end
+
     def consumers
-      @consumers ||= JSON.parse RestClient.get("#{@url}consumers", :content_type => :json, :accept => :json);
+      user["consumers"]
     end
 
     def providers
-      @providers ||= JSON.parse RestClient.get("#{@url}providers", :content_type => :json, :accept => :json);
+      user["providers"]
     end
 
     def user_name
@@ -37,7 +69,7 @@ module Fenris
     end
 
     def route
-      "#{user["ip"]}:#{user["port"]}" if user["ip"]
+      user["location"]
     end
 
     def remove(name)
@@ -48,6 +80,22 @@ module Fenris
       RestClient.post("#{@url}consumers", { :name => name }, :content_type => :json, :accept => :json);
     end
 
+    def useradd(name)
+      JSON.parse RestClient.post("#{@url}users", { :name => name }, :content_type => :json, :accept => :json);
+    end
+
+    def rekey
+      RestClient.post("#{@url}authkeys", { }, :content_type => :json, :accept => :json);
+    end
+
+    def users
+      JSON.parse RestClient.get("#{@url}users", :content_type => :json, :accept => :json)
+    end
+
+    def userdel(name)
+      RestClient.delete("#{@url}users/#{name}", :content_type => :json, :accept => :json);
+    end
+
     def bind(name, binding)
       RestClient.put("#{@url}providers/#{name}", { :binding => binding }, :content_type => :json, :accept => :json);
     end

data/lib/fenris/command.rb

@@ -1,16 +1,40 @@
 module Fenris
   module Command
-    def self.run(command, arg=nil, name=nil)
+    def self.run(command, *args)
+      arg, name = args
       begin
-        client = Fenris::Client.new(ENV['FENRIS_URL']);
+        url = URI.parse(ENV['FENRIS_URL'] || 'https://broker.fenris.cc')
+        url.user ||= ENV['FENRIS_USER']
+        url.password ||= ENV['FENRIS_AUTHKEY']
+        client = Fenris::Client.new url
         help = [ "Usage: fenris help\n",
                  "       fenris info\n",
                  "       fenris bind PROVIDER BINDING\n",
+                 "       fenris useradd NAME\n",
+                 "       fenris userdel NAME\n",
+                 "       fenris users\n",
+                 "       fenris rekey\n",
                  "       fenris add CONSUMER\n",
                  "       fenris remove CONSUMER\n",
-                 "       fenris serve BINDING\n",
-                 "       fenris connect [ USER [ BINDING ] ]" ]
+                 "       fenris exec COMMAND\n",
+                 "       fenris provide BINDING\n",
+                 "       fenris consume [ USER [ BINDING ] ]" ]
         case command
+          when "users"
+            client.users.each do |u|
+              puts u["name"]
+            end
+          when "userdel"
+            client.userdel(arg)
+          when "useradd"
+            new_user = client.useradd(arg)
+            puts "New user created"
+            puts "export FENRIS_USER='#{new_user["name"]}'"
+            puts "export FENRIS_AUTHKEY='#{new_user["authkey"]}'"
+          when "rekey"
+            newkey = client.rekey
+            puts "New Key Assigned:"
+            puts "export FENRIS_AUTHKEY='#{newkey}'"
           when "cert"
             puts client.cert.to_text
           when "bind"
@@ -28,14 +52,16 @@ module Fenris
             end
             unless client.providers.empty?
               puts "SERVICES:"
-              client.providers.each { |c| puts "    #{c["binding"] || "unbound"} #{c["name"]} (#{c["provider"]}) #{c["ip"]} #{c["port"]}" }
+              client.providers.each { |c| puts "    #{c["binding"] || "unbound"} #{c["name"]} (#{c["description"]}) #{c["location"]}" }
             end
-          when "serve"
-            from = 10001
-            to = arg
-            Fenris::Base.serve(client, from, to)
-          when "connect"
-            Fenris::Base.connect(client, arg, name)
+          when "provide"
+            external = "#{Socket.gethostname}:#{10001}"
+            internal = arg
+            Fenris::Base.provide(client, external, internal)
+          when "consume"
+            Fenris::Base.consume(client, arg, name)
+          when "exec"
+            Fenris::Base.exec(client, *args)
           else
             puts command.inspect
             puts help
@@ -43,6 +69,10 @@ module Fenris
         exit
       end
     rescue SystemExit
+    rescue RestClient::Conflict
+      puts "Duplicate"
+    rescue RestClient::Unauthorized
+      puts "Unauthorized"
     rescue RestClient::ResourceNotFound
       puts "Resource Not Found"
       exit

data/lib/fenris/em.rb

@@ -23,13 +23,17 @@ module Fenris
       @validator = blk;
     end
 
+    def on_unbind(&blk)
+      @on_unbind = blk
+    end
+
     def ssl_verify_peer(pem)
       @verify ||= @validator.call(pem)
     end
 
     def unbind
+      @on_unbind.call(self) if @on_unbind
       @unbound = true
-      puts "DEBUG: unbind #{@signature}"
       EM::stop if @signature < 3 ## this is for attach($stdin)
       @peer.close_connection_after_writing rescue nil
       close_connection
@@ -53,43 +57,45 @@ module Fenris
   module Base
     extend self
 
-    def producer_server(client, from, to)
-      return producer_server_stdio(client, from, to) if to == "--"
-      EventMachine::__send__ *mkbinding(:start_server, from), Fenris::Connection do |consumer|
+    UPDATE_INTERVAL = 2
+
+    def listen(client, external, internal)
+      return listen_stdio(client, external, internal) if internal == "--"
+      EventMachine::__send__ *mkbinding(:start_server, external), Fenris::Connection do |consumer|
         client.log "New connection - begin ssl handshake"
         consumer.validate_peer { |pem| client.validate_peer pem  }
         consumer.begin_ssl :key_file =>  client.key_path , :cert_file => client.cert_path do
           client.log "SSL complete - open local connection"
-          EventMachine::__send__ *mkbinding(:connect, to), Fenris::Connection do |producer|
+          EventMachine::__send__ *mkbinding(:connect, internal), Fenris::Connection do |provider|
             client.log "start proxying"
-            producer.proxy consumer; consumer.proxy producer
+            provider.proxy consumer; consumer.proxy provider
           end
         end
       end
     end
 
-    def producer_server_stdio(client, from, to)
-      EventMachine::__send__ *mkbinding(:connect, to), Fenris::Connection do |producer|
-        EventMachine::__send__ *mkbinding(:start_server, from), Fenris::Connection do |consumer|
+    def listen_stdio(client, external, internal)
+      EventMachine::__send__ *mkbinding(:connect, internal), Fenris::Connection do |provider|
+        EventMachine::__send__ *mkbinding(:start_server, external), Fenris::Connection do |consumer|
           client.log "stdio connection - begin ssl handshake"
           consumer.validate_peer { |pem| client.validate_peer pem  }
           consumer.begin_ssl :key_file =>  client.key_path , :cert_file => client.cert_path do
             client.log "SSL complete - start proxying"
-            producer.proxy consumer; consumer.proxy producer
+            provider.proxy consumer; consumer.proxy provider
           end
         end
       end
     end
 
-    def serve(client, listen_port, to)
+    def provide(client, external, internal)
       at_exit { client.cleanup }
 
       EventMachine::run do
         client.save_keys
-        client.update "0.0.0.0", listen_port
-        from = "0.0.0.0:#{listen_port}"
-        client.log "Serving port #{to} on #{from}"
-        producer_server(client, from, to)
+        EventMachine::PeriodicTimer.new(UPDATE_INTERVAL) { client.async_update }
+        client.update external
+        client.log "Serving port #{internal} on #{external}"
+        listen client, external, internal
       end
     end
 
@@ -107,6 +113,7 @@ module Fenris
 
     ## really want to unify all these :(
     def consumer_connect(client, consumer, provider_name, provider)
+      client.log "COMSUMER CONNECT #{consumer.inspect} #{provider_name.inspect} #{provider.inspect}"
       EventMachine::__send__ *mkbinding(:start_server, consumer), Fenris::Connection do |consumer|
         client.log "New connection: opening connection to the server"
         EventMachine::__send__ *mkbinding(:connect, provider), Fenris::Connection do |provider|
@@ -120,7 +127,7 @@ module Fenris
       end
     end
 
-    def connect(client, overide_provider = nil, override_binding = nil)
+    def consume(client, overide_provider = nil, override_binding = nil)
       at_exit { client.cleanup }
 
       client.save_keys
@@ -133,13 +140,27 @@ module Fenris
       abort "Can only pass a binding for a single provider" if override_binding && providers.length != 1
 
       EventMachine::run do
+        EventMachine::PeriodicTimer.new(UPDATE_INTERVAL) { client.async_update }
         providers.each do |p|
           binding = override_binding || p["binding"]
-          consumer_connect(client, binding, p["name"], "#{p["ip"]}:#{p["port"]}")
+          consumer_connect(client, binding, p["name"], p["location"])
+        end
+      end
+    end
+
+    def exec(client, *args)
+      command = args.join(' ')
+      EventMachine::run do
+        consume(client)
+        stdin = EventMachine.attach $stdin, Connection
+        EventMachine::popen command, Connection do |ps|
+          puts "execing command '#{command}'"
+          ps.on_unbind { EventMachine::stop }
+          stdin.on_unbind { EventMachine::stop }
+          ps.proxy stdin; stdin.proxy ps
         end
       end
     end
   end
 end
 
-

data/lib/fenris/version.rb

@@ -1,3 +1,3 @@
 module Fenris
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: fenris
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   segments:
   - 0
   - 0
-  - 1
+  - 2
   prerelease: false
 platform: ruby
 authors:
@@ -13,12 +13,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-18 00:00:00.000000000 -07:00
+date: 2011-10-24 00:00:00.000000000 -07:00
 default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &2168813480 !ruby/object:Gem::Requirement
+  requirement: &2155696200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -30,10 +30,10 @@ dependencies:
         - 10
   type: :runtime
   prerelease: false
-  version_requirements: *2168813480
+  version_requirements: *2155696200
 - !ruby/object:Gem::Dependency
   name: rest-client
-  requirement: &2168811760 !ruby/object:Gem::Requirement
+  requirement: &2155694060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -45,10 +45,10 @@ dependencies:
         - 7
   type: :runtime
   prerelease: false
-  version_requirements: *2168811760
+  version_requirements: *2155694060
 - !ruby/object:Gem::Dependency
   name: multi_json
-  requirement: &2168810220 !ruby/object:Gem::Requirement
+  requirement: &2155692380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -60,7 +60,7 @@ dependencies:
         - 3
   type: :runtime
   prerelease: false
-  version_requirements: *2168810220
+  version_requirements: *2155692380
 description: An authentication and service location service.
 email: orion.henry@gmail.com
 executables: