openplacos 0.0.8 → 0.0.9

data/VERSION

@@ -1 +1 @@
-0.0.8
+0.0.9

data/lib/openplacos.rb

@@ -15,6 +15,5 @@
 #
 
 # Please keep as it, each file should be included separetly
-require 'openplacos/libplugin'
+require 'openplacos/libcomponent'
 require 'openplacos/libclient'
-require 'openplacos/libdriver'

data/lib/openplacos/libclient.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 #    This file is part of Openplacos.
 #
 #    Openplacos is free software: you can redistribute it and/or modify
@@ -13,177 +14,413 @@
 #    You should have received a copy of the GNU General Public License
 #    along with Openplacos.  If not, see <http://www.gnu.org/licenses/>.
 
+require 'socket'
+require 'net/http'
+require 'json'
+require 'oauth2'
+require 'yaml'
+
+require File.dirname(__FILE__) + "/widget/modules.rb"
+
+
+module OAuth2
+  class AccessToken
+    def to_hash()
+      token_params = @params
+      token_params['access_token'] = @token
+      token_params.merge!(@options)
+      token_params
+    end
+
+  end
+end
 
-ENV["DBUS_THREADED_ACCESS"] = "1" #activate threaded dbus
-require 'dbus-openplacos'
 
 module Openplacos
-  class Client # client for openplacos server 
-    attr_accessor :config, :objects, :service, :sensors, :actuators, :rooms,  :reguls, :initial_room
-    
-    def initialize
-      if(ENV['DEBUG_OPOS'] ) ## Stand for debug
-        @bus =  DBus::SessionBus.instance
+
+  module String
+
+    # this method extend string module. 
+    # this module find out a module instance from it's name (=string)
+    # ( "Openplacos::Analog" (=string) => Oenplacos::Analog (= module)  
+    def get_max_const
+      array = self.split("::")
+      out = Kernel
+      array.each { |mod|
+        if out.const_defined?(mod)
+          out = out.const_get(mod)
+        else
+          return out
+        end
+      }
+      return out #Should never be here
+    end
+  end
+  
+  module Connection
+
+    # register the client (automatic way)
+    def register( )
+      postData = Net::HTTP.post_form(URI.parse("#{@url}/oauth/apps"), 
+                                     { 'name'        =>"#{@name}",
+                                       'redirect_uri'=>@redirect_uri,
+                                       'format'      =>'json'
+                                     }
+                                     )
+      if postData.code == "200"            # Check the status code   
+        client_param = JSON.parse( postData.body)
       else
-        @bus =  DBus::SystemBus.instance
+        puts "error code"
+        exit 0
       end
-      if @bus.service("org.openplacos.server").exists?
-        @service = @bus.service("org.openplacos.server")
-        @service.introspect
-        #discover all objects of server
-        @initial_room = Room.new(nil, "/")   
-        @objects = get_objects(@service.root, @initial_room)
-        @rooms = @initial_room.tree
-
-        
-        #get sensors and actuators
-        @sensors = get_sensors
-        @actuators = get_actuators
-        @reguls = get_reguls
-        
-        @permissions = Hash.new
+
+      @client_id = client_param["client_id"]
+      @client_secret = client_param["client_secret"]
+    end
+
+    def create_client
+      @client = OAuth2::Client.new(@client_id,
+                                   @client_secret,
+                                   {:site => "#{@url}", 
+                                     :token_url => '/oauth/authorize'
+                                   }
+                                   ) 
+    end
+
+    def get_grant_url(type_)
+      @client.auth_code.authorize_url(:redirect_uri => @redirect_uri, :scope => @scope.join(" "))
+    end
+
+    # save config with token, client_id and secret into a userspace directory
+    # needed to not regrant client every connection
+    def save_config
+      @token_params[@url]                 = @token ? @token.to_hash : {}
+      @token_params[@url][:client_id]     = @client_id
+      @token_params[@url][:client_secret] = @client_secret
+
+      File.open(@file_config, 'w') do |out|
+        YAML::dump( @token_params, out )
+      end
+    end
+
+    # restore config 
+    def load_config
+      if File.exists?(@file_config)
+        @token_params  = YAML::load(File.read(@file_config))
+        if @token_params[@url]
+          @client_id     = @token_params[@url][:client_id] 
+          @client_secret = @token_params[@url][:client_secret]
+        end
       else
-        puts "Can't find OpenplacOS server"
-        Process.exit 1
+        @token_params = Hash.new
       end
+    end
+       
+    def recreate_token
+      @token = OAuth2::AccessToken.from_hash(@client, @token_params[@url])
+    end
+
+  end
+
+  class Connection_password
+    include Connection
+    attr_reader :token
+    def initialize(url_, name_, scope_, id_, port_, username_, password_)
+      @url          = url_
+      @name         = name_
+      @scope        = scope_
+      @id           = id_
+      @redirect_uri = "http://0.0.0.0:#{port_}"
+      @port         = port_
+      @username     = username_
+      @password     = password_
       
-    
-    end  
-    
-    def get_objects(nod, father_) #get objects from a node, ignore Debug objects
-      obj = Hash.new
-      nod.each_pair{ |key,value|
-       if not(key=="Debug" or key=="server" or key=="plugins" or key=="Authenticate") #ignore debug objects
-         if not value.object.nil?
-           obj[value.object.path] = value.object
-           father_.push_object(value.object)
-         else
-           children = father_.push_child(key)
-           obj.merge!(get_objects(value, children))
-         end
-       end
-      }
-      obj
+      
+      dir_config = "#{ENV['HOME']}/.openplacos"
+      if !Dir.exists?(dir_config)
+        Dir.mkdir(dir_config)
+      end
+
+      @file_config = "#{dir_config}/#{@name}-#{id_}.yaml"
+      
+      load_config
+      if @token_params[@url].nil? #create -- first time
+        register 
+        create_client
+        save_config
+      else        # persistant mode
+        create_client
+      end
+      get_token 
+
     end
     
-    def get_config_from_objects(objects) #contact config methods for all objects
-      cfg = Hash.new
-      objects.each_pair{ |key, obj|
-        if not(obj["org.openplacos.server.config"]==nil)
-          cfg[key] = obj["org.openplacos.server.config"].getConfig[0] 
-        end
-      }
-      cfg
-    end
+    private 
     
-    def get_sensors
-      sensors = Hash.new
-      @objects.each_pair{ |key, value|
-        if value.has_iface?('org.openplacos.server.measure')
-          sensors[key] = value['org.openplacos.server.measure']
-        end
-      }
-      sensors  
+    def get_token
+      begin
+        @token = @client.password.get_token(@username, @password, {:redirect_uri => @redirect_uri},{:mode=>:header, :header_format=>"OAuth %s", :param_name=>"oauth_token"})
+      rescue => e
+       puts e
+       retry
+      end
     end
     
-    def is_regul(sensor)
-      # get dbus object of sensor
-      key = get_sensors.index(sensor)
-      if (key == nil)
-        return false
+  end
+
+  class Connection_auth_code
+    include Connection
+    attr_reader :token
+
+    # Open a connection to openplacos server
+    # Please give:
+    # * opos url
+    # * an application name that identify the client oath2 talking
+    # * a scope, typically ["read", "write", "user"] 
+    # * an optionnal id, to manage several clients
+    # * port of openplacos server
+    def initialize(url_, name_, scope_, id_, port_)
+      @url = url_
+      @name = name_
+      @scope = scope_
+      @redirect_uri = "http://0.0.0.0:#{port_}"
+      @port = port_
+
+      dir_config = "#{ENV['HOME']}/.openplacos"
+      if !Dir.exists?(dir_config)
+        Dir.mkdir(dir_config)
       end
 
-      # Test interface
-      if (@objects[key].has_iface?('org.openplacos.server.regul'))
-        return true
-      else
-        return false
+      # config saved to avoir re-grant at each connection
+      @file_config = "#{dir_config}/#{@name}-#{id_}.yaml"
+      
+      load_config
+      if @token_params[@url].nil? #get token -- first time
+        register 
+        create_client
+        grant
+        get_token
+        save_config
+      else        # persistant mode
+        create_client
+        recreate_token
       end
     end
 
-    def get_regul_iface(sensor)
-      if (is_regul(sensor)==nil)
-        return nil
+private
+    # display a message indicating url for grant
+    # this method can be overloaded by client depending it's interface with user
+    def grant ()
+      go_to_url  = get_grant_url("code")
+
+      puts "***************"
+      puts "Please open your web browser and got to :"
+      puts go_to_url
+      puts "***************"
+
+      @auth_code = get_auth_code
+    end
+
+    def get_auth_code()
+      # listen to get the auth code
+      server = TCPServer.new(@port)
+      re=/code=(.*)&scope/
+      authcode = nil
+      while (session = server.accept)
+        request = session.gets
+        authcode = re.match(request)
+        if !authcode.nil?
+          session.print "HTTP/1.1 200/OK\rContent-type: text/html\r\n\r\n"
+          session.puts "<h1>Auth successfull</h1>"
+          session.close
+          break 
+        end
+      end
+      authcode[1]
+    end
+
+    def get_token()
+      begin
+        @token = @client.auth_code.get_token(@auth_code, {:redirect_uri => @redirect_uri},{:mode=>:header, :header_format=>"OAuth %s", :param_name=>"oauth_token"})
+      rescue => e
+        puts e.description
+        Process.exit 42
       end
-      key = get_sensors.index(sensor)
-      return @objects[key]['org.openplacos.server.regul']
     end
+    
+  end
 
-    def get_actuators
-      actuators = Hash.new
-      @objects.each_pair{ |key, value|
-        if value.has_iface?('org.openplacos.server.actuator')
-          actuators[key] = value['org.openplacos.server.actuator']
+
+  class Connection_from_token
+    attr_accessor :token
+    def initialize(tok_)
+      @token = tok_
+    end
+  end
+  
+  class Client
+
+    attr_accessor :config, :objects, :service, :sensors, :actuators, :rooms,  :reguls, :initial_room
+    
+    # Initialize a connection to server with OAuth2 in a automatic way
+    # Please provide url server, application name, permission needed for application
+    # Set connection_type to auth_code to use with oauth2 flow
+    # You can access to proxyfied objects with .objects attribute
+    # Please give:
+    # * opos url
+    # * an application name that identify the client oath2 talking
+    # * a scope, typically ["read", "write", "user"] 
+    # * a connection_type, set it to "auth_code" to use oauth2 with classic flow (recommanded)
+    # or with "password" to use with password flow. Set to "inception" to pass a connection
+    # object through opt{:connection} 
+    # * an optionnal id, to manage several clients
+    # * an optionnal option hash, in which you can specify openplacos port { :port => 5454 }
+    # * You can also pass a token object through opt[:token] that is an oauth2 object. 
+    def initialize(url_, name_, scope_, connection_type_, id_ = "0", opt_={})
+
+      @objects = Hash.new
+      @connection_type = connection_type_
+      if opt_[:token].nil?
+        case @connection_type
+        when "auth_code" then
+          @connection =  Connection_auth_code.new(url_, name_, scope_, id_, opt_[:port] || 2000)
+        when "password" then
+          @connection = Connection_password.new(url_, name_, scope_, id_, opt_[:port] || 2000, opt_[:username], opt_[:password])
+        else
+          raise "unknow grant type"
         end
+      else
+        @connection = Connection_from_token.new(opt_[:token])
+      end
+      introspect
+      extend_objects
+    end
+
+    # Intropect the distant server
+    def introspect
+      @introspect = JSON.parse( @connection.token.get('/ressources').body)
+      @introspect.each { |obj|
+        @objects[obj["name"]] = ProxyObject.new(@connection, obj) 
       }
-      actuators
     end
     
-    def get_reguls
-      reguls = Hash.new
-      @objects.each_pair{ |key, value|
-        if value.has_iface?('org.openplacos.server.regul')
-          reguls[key] = value['org.openplacos.server.regul']
+    def get_iface_type(obj, det_)
+      a = Array.new
+      obj.interfaces.each { |iface|
+        if(iface.include?(det_))
+          a << iface
         end
       }
-      reguls
+      a
     end
     
-    def auth(login_,password_)
-      authobj = @service.object("/Authenticate")["org.openplacos.authenticate"]
-      ack,perm = authobj.authenticate(login_,password_)
-      if ack==true
-        if @permissions[login_].nil?
-          @permissions[login_] = perm
+    def extend_objects
+      @objects.each_pair{ |key, obj|
+        if (key != "/informations")
+          obj.interfaces.each { |iface|
+            extend_iface(iface, obj[iface])
+          }
         end
-      end
-      return ack
+      }
     end
     
-    def readable?(path_,login_)
-      return true if @permissions[login_]["read"].include?(path_)
-      #check if one object is readable in the room
-      @permissions[login_]["read"].each { |path|
-        return true if path.include?(path_)
+    # Extend an object to a ruby module according to iface_name_
+    # if iface_name_ is "org.openplacos.analog.order"
+    # => object will inherit Openplacos::Analog::Order
+    def extend_iface(iface_name_,obj_ )
+      mod = "Openplacos::"+ construct_module_name(iface_name_)
+      mod.extend(Openplacos::String)
+      obj_.extend(mod.get_max_const)
+    end
+
+    # transform iface_name to a module name that obj will inherit
+    def construct_module_name(iface_name_)
+      iface_heritage = iface_name_.sub(/org.openplacos./, '').split('.')
+      iface_heritage.each { |s|
+        s.capitalize!
       }
-      return false #else
+      iface_heritage.join('::')
     end
     
-    def writeable?(path_,login_)
-      return @permissions[login_]["write"].include?(path_)
+    # return the user name
+    def me
+      JSON.parse(@connection.token.get("/me").body)["username"]
     end
-    
+   
   end
 
-  class Room
-    attr_accessor :father, :childs, :path, :objects
 
-    def initialize(father_, path_)
-      @father = father_
-      @path = path_
-      @childs = Array.new
-      @objects = Hash.new
-   end
+  class ProxyObject
+  
+    attr_reader :path
+    
+    # Object abstraction of a ressources
+    # Contructed from instrospect
+    # Has interfaces
+    def initialize(connection_, introspect_)
+      @path = introspect_["name"]
+      @interfaces = Hash.new
+      introspect_["interfaces"].each_pair { |name, methods|
+        @interfaces[name]= ProxyObjectInterface.new(connection_, self, name, methods)
+      }
+    end
+    
+     # Returns the interfaces of the object.
+    def interfaces
+      @interfaces.keys
+    end
 
-    def push_child (value_)
-      children = Room.new(self, self.path  + value_ + "/")
-      @childs << children
-      return children
+    # Retrieves an interface of the proxy object (ProxyObjectInterface instance).
+    def [](intfname)
+      @interfaces[intfname]
     end
 
-    def push_object(obj_)
-      @objects.store(obj_.path, obj_)
+    # Maps the given interface name _intfname_ to the given interface _intf.
+    def []=(intfname, intf)
+      @interfaces[intfname] = intf
+    end 
+
+    def has_iface?(iface_)
+      return interfaces.include?(iface_)
     end
-    
-    def tree()
-      hash = Hash.new
-      hash.store(@path, self)
-      @childs.each { |child|
-        hash.merge!(child.tree)
+   
+  end
+
+  class ProxyObjectInterface
+
+    # Interface abstraction
+    # contruct from introspect
+    def initialize(connection_, proxyobj_, name_, methods_)
+      @connection = connection_
+      @proxyobject = proxyobj_
+      @name    = name_
+      @methods = Hash.new
+      methods_.each {  |meth|
+        @methods[meth] = define_method(meth)
       }
-      return hash
     end
-   
+
+    # Define a proxyfied method from its name
+    def define_method(name_)
+     if name_=="read"
+     methdef =  <<-eos
+                   def read(option_ = {})
+                     res = JSON.parse(@connection.token.get('/ressources/#{@proxyobject.path}', :params => {'iface'=> '#{@name}', 'options' => (option_).to_json}).body)
+                     res["value"]
+                   end
+eos
+    end
+    if name_=="write"
+     methdef =  <<-eos
+                   def write(value_,option_ = {})
+                     res = JSON.parse(@connection.token.post('/ressources/#{@proxyobject.path}', :params => {'iface'=> '#{@name}', 'value' => [value_].to_json, 'options' => (option_).to_json}).body)
+                     res["status"]
+                   end
+eos
+    end
+    
+        instance_eval( methdef )
+      end
   end
- 
+
 end