pastehub 0.2.6 → 0.4.0

data/lib/pastehub/clientsync.rb

@@ -1,7 +1,7 @@
 #
 # clientsync.rb - PasteHub's client sync library
 #  
-#   Copyright (c) 2009-2011  Kiyoka Nishiyama  <kiyoka@sumibi.org>
+#   Copyright (c) 2009-2014  Kiyoka Nishiyama  <kiyoka@sumibi.org>
 #   
 #   Redistribution and use in source and binary forms, with or without
 #   modification, are permitted provided that the following conditions
@@ -35,253 +35,215 @@ require 'net/http'
 require 'uri'
 require 'open-uri'
 require 'fileutils'
+require 'json'
 
 module PasteHub
 
-  class ClientSync
+  class Status
+    TIMER_INIT = 60 # second
 
-    def initialize( alive_entries, localdb_path, polling_interval )
-      @alive_entries        = alive_entries
-      @localdb_path         = localdb_path
-      @polling_interval     = polling_interval
+    def initialize( )
+      @comes      = 0
+      @online     = false
+      @errorFlag  = false
+      @timer      = TIMER_INIT
+      @curJsonStr = ""
+    end
+    
+    def inc( )
+      @comes += 1
+      @timer     = TIMER_INIT
+    end
+    
+    def reset( )
+      @comes = 0
+      @timer     = TIMER_INIT
+    end
+    
+    def setOnline( arg )
+      @online = arg
     end
 
-
-    def syncDb( auth, password )
-      notifyFlag = false
-
-      STDERR.puts "synchronizing..."
-      client = PasteHub::Client.new( auth, password )
-      util   = PasteHub::Util.new
-      # open local db
-      localdb = PasteHub::LocalDB.new( @localdb_path )
-      localdb.open( auth.username, true )
-
-      masterList = localdb.getServerList()
-      #pp [ "masterList.size", masterList.size ]
-
-      # calc difference between master and local.
-      localList = localdb.getList()
-      #pp [ "localList.size(1)", localList.size ]
-
-      # pickup first ALIVE_ENTRIES from localList
-      #_half0 = util.takeList( localList,  @alive_entries )
-      _half1 = util.dropList( masterList,  @alive_entries )
-      localList = localList + _half1
-      #pp [ "localList.size(2)", localList.size ]
-
-      downList = util.diffList( masterList, localList )
-      #pp [ "downList.size", downList.size ]
-
-      upList   = util.diffList( localList,  masterList )
-      #pp [ "upList.size", upList.size ]
-
-      # push first element to clipboard.
-      if 0 < downList.size
-        key = downList.first
-        value = client.getValue( key )
-        if @prevData == value
-          #p [ @prevData , value ]
-          STDERR.puts "Info: did not push to OS's clipboard because prevData == donwloaded-firstEntry."
-        else
-          STDERR.printf( "Info: push to OS's clipboard (size=%d).\n", value.size )
-          PasteHub::AbstractClipboard.push( value.dup )
-          notifyFlag = true
-          @prevData = value
-        end
+    def tick( delta )
+      if @timer <= 0
+        @comes = 0
+      else
+        @timer -= delta
       end
+    end
 
-      # donwload
-      downList.each {|key|
-        value = client.getValue( key )
-        localdb_w = PasteHub::LocalDB.new( @localdb_path )
-        localdb_w.open( auth.username )
-        localdb_w.insertValue( key.dup, value.dup )
-        localdb_w.close
-        sleep( 0.2 )
-      }
-      # upload
-      upList.each {|key|
-        value = localdb.getValue( key )
-        client.putValue(     key.dup, value.dup )
-      }
+    def update( )
+      prev = @curJsonStr
+      h = Hash.new
+      h[ 'online' ] = @online
+      h[ 'error'  ] = @errorFlag
+      h[ 'comes'  ] = @comes
+      @curJsonStr = JSON.dump( h )
+      return [ @curJsonStr, prev ]
+    end
 
-      STDERR.puts "Info: download #{downList.size} records."
-      downList.each { |x|
-        #STDERR.puts "  key=#{x}"
-      }
-      STDERR.puts "Info:   upload #{upList.size} records."
-      upList.each { |x|
-        #STDERR.puts "  key=#{x}"
-      }
-      localdb.close()
+    def icon( )
+      result = if @errorFlag
+                 "error"
+               elsif not @online
+                 "offline"
+               else
+                 case @comes
+                 when 0
+                   "online"
+                 when 1
+                   "one"
+                 when 2
+                   "two"
+                 when 3
+                   "three"
+                 else
+                   "threeplus"
+                 end
+               end
+      return result
+    end
+  end
 
-      if 0 < downList.size or 0 < upList.size
-        STDERR.puts "Info:   send signal to Emacs."
-        system( "killall -SIGUSR1 Emacs emacs" )
-      end
+  class ClientSync
+    ICONSOCKET = "/tmp/pastehub_icon"
 
-      return notifyFlag
+    def initialize( hostname, polling_interval )
+      @hostname             = hostname
+      @polling_interval     = polling_interval
+      @status               = Status.new()
+      @last_modify_time     = Time.now()
     end
 
+    def addNoitfyCallback( receiveNotifyFunc )
+      @receiveNotifyFunc    = receiveNotifyFunc 
+    end
+ 
+    def notifyToReceive( message )
+      @receiveNotifyFunc.call( message ) if @receiveNotifyFunc
+      @status.inc( )
+    end
 
-    def gcLocalDb( auth )
-      STDERR.puts "GCing..."
-
-      # open local db
-      localdb_w = PasteHub::LocalDB.new( @localdb_path )
-      localdb_w.open( auth.username )
-      localList = localdb_w.getList()
-      deleteList = localList[@alive_entries..(localList.size)]
-      if deleteList and 0 < deleteList.size
-        STDERR.puts "Info:   delete #{deleteList.size} records."
-        deleteList.each { |key|
-          localdb_w.deleteValue( key.dup )
-        }
-      end
-      localdb_w.close
+    # host's sync data file excludes local hostname
+    def get_other_hostfiles()
+      config = PasteHub::Config.instance
+      arr = Dir.glob( config.localSyncPath + "*.dat" )
+      retArr = arr.select { |path|
+        not path.match( "/" + @hostname + ".dat$" )
+      }
+      retArr
     end
 
+    # return: pathname of sync data of other host
+    def exist_sync_data?()
+      # check directory changes
+      config = PasteHub::Config.instance
+
+      paths = get_other_hostfiles()
+      result = paths.select { |path|
+        fs = File::Stat.new( path )
+        fs.mtime
 
-    def fetchServerList( latestKey, auth )
-      client = PasteHub::Client.new( auth )
-      if latestKey.is_a? String
-        STDERR.puts "Info: fetch one entry"
-        list = [ latestKey.clone() ]
+        #printf( "last_modify_time: %s \n", @last_modify_time )
+        #printf( "mtime of [%s]: %s \n", path, fs.mtime )
+        1 == (fs.mtime <=> @last_modify_time)
+      }
+      if 0 < result.size
+        result[0]
       else
-        STDERR.puts "Info: fetch ALL entries"
-        list = client.getList()
+        nil
       end
-      client.setServerFlags( list )
     end
 
-    def addNoitfyCallback( countUpNotifyFunc, connectNotifyFunc, disconnectNotifyFunc )
-      @countUpNotifyFunc     = countUpNotifyFunc
-      @connectNotifyFunc     = connectNotifyFunc
-      @disconnectNotifyFunc  = disconnectNotifyFunc
+    def path_to_hostname( path )
+      File.basename( path, ".dat" )
     end
 
-    def notifyCountUp()
-      @countUpNotifyFunc.call() if @countUpNotifyFunc
+    def get_sync_entry_body( path )
+      hostname = path_to_hostname( path )
+      entry = Entry.new( hostname )
+      if entry.can_load?()
+        entry.load()[1]
+      else
+        nil
+      end
     end
 
-    def notifyConnect()
-      @connectNotifyFunc.call() if @connectNotifyFunc
+    def get_latest_entry( )
+      # check directory changes
+      config = PasteHub::Config.instance
+
+      paths = get_other_hostfiles()
+      result = paths.map { |path|
+        hostname = path_to_hostname( path )
+        entry = Entry.new( hostname )
+        if entry.can_load?()
+          ret = entry.load()
+          [ ret[0]['create_unixtime'].to_i, ret[0], ret[1] ]
+        else
+          [ 0, nil, nil ]
+        end
+      }
+      if 0 == result.size()
+        nil
+      else 
+        result = result.sort {|a,b| a[0] <=> b[0]}.reverse
+        [
+         result[0][1], result[0][2]
+        ]
+      end
     end
 
-    def notifyDisconnect()
-      @disconnectNotifyFunc.call() if @disconnectNotifyFunc      
+    def touch( )
+      @last_modify_time     = Time.now()
     end
 
+    def sync_main()
+      config = PasteHub::Config.instance
 
-    def syncMain( username, secretKey, password )
-      freeCounter = 0
-
-      auth   = PasteHub::AuthForClient.new( username, secretKey )
-      client = PasteHub::Client.new( auth )
-      client.setOnlineState( false )
-      client.setOnlineState( true )  # create Trigger token  ___-___
-      client.setOnlineState( false )
-      result = :start
+      STDERR.puts "Info: sync_main thread start"
+      free_counter = 0
 
       while true
-        begin
-          freeCounter += 1
-
-          if client.getTrigger() or (0 == (freeCounter % 60))
-            STDERR.puts "Info: force sync."
-            result = :sync
-            gcLocalDb( auth )
-          else
-            auth   = PasteHub::AuthForClient.new( username, secretKey )
-            result = client.wait_notify( auth )
-          end
-
-          case result
-          when :timeout
-            STDERR.puts "waiting..."
-            client.setOnlineState( true )
-            notifyConnect()
-          when :retry
-            STDERR.puts "retrying...."
-            client.setOnlineState( false )
-            notifyDisconnect()
-            sleep 60
+        free_counter += 1
+
+        path = exist_sync_data?()
+        if path
+          body = get_sync_entry_body( path )
+          if body
+            STDERR.printf( "Info: push to OS's clipboard ([%s...] size=%d).\n", body[0...4], body.size )
+            PasteHub::AbstractClipboard.push( body.dup )
+            touch()
           else
-            if not client.online?()
-              notifyConnect()
-            end
-            client.setOnlineState( true )
-            fetchServerList( result, auth )
-            if syncDb( auth, password )
-              notifyCountUp()
-            end
+            STDERR.printf( "X" )   if config.getVerbose( )
           end
-        rescue Errno::EAGAIN => e
-          STDERR.puts "retrying... DB is locked"
-          notifyDisconnect()
-          sleep 2
-        rescue Errno::ECONNREFUSED => e
-          STDERR.puts "retrying... pastehub server is down(1)"
-          notifyDisconnect()
-          sleep 60
-        rescue Errno::ETIMEDOUT => e
-          STDERR.puts "retrying... network is offline(1)"
-          notifyDisconnect()
-          sleep 60
-        rescue SocketError => e
-          STDERR.puts "retrying... network is offline(2)"
-          notifyDisconnect()
-          sleep 60
-        rescue Timeout::Error => e
-          # ONLINE, but server is not helthy
-          notifyDisconnect()
-          STDERR.puts "retrying... pastehub server is down(2)"
-          sleep 60
+        else
+          STDERR.printf( "x" )    if config.getVerbose( )
         end
+        # interval time
+        sleep @polling_interval
       end
     end
 
+    def clipboard_check()
+      config = PasteHub::Config.instance
 
-    def clipboardCheck( username, secretKey, password )
       STDERR.puts "Info: clipboardCheck thread start"
       @prevData = ""
       while true
         sleep @polling_interval
-        data = PasteHub::AbstractClipboard.hasNew?( username )
+        data = PasteHub::AbstractClipboard.hasNew?( )
         if data
           if @prevData != data
-            #p [ @prevData, data ]
-            auth = PasteHub::AuthForClient.new( username, secretKey )
-            client = PasteHub::Client.new( auth, password )
-            if client.online?(  )
-              STDERR.puts( "Info: posted data from OS." )
-              begin
-                client.putValue( "_", data )
-              rescue Errno::ECONNREFUSED => e
-                # if postData was fail, save to local.
-                client.setOnlineState( false )
-                client.localSaveValue( data )
-                sleep 60
-              end
-            else
-              client.localSaveValue( data )
-            end
+            entry = Entry.new( @hostname )
+            entry.save( data )
+            STDERR.printf( "Info: clipboard to File ([%s...] size=%d).\n", data[0...4], data.size )
+            notifyToReceive( data )
             @prevData = data
           end
         end
+        STDERR.printf( "." )    if config.getVerbose( )
       end
     end
-
-
-    def syncNow( username, secretKey, password )
-      STDERR.puts( "Info: caught signal." )
-      store = PasteHub::LocalStore.new( username, true )
-      pair = store.top()
-      auth = PasteHub::AuthForClient.new( username, secretKey )
-      client = PasteHub::Client.new( auth, password )
-      client.putValue( pair[0], pair[1] )
-    end
-
   end
 end

data/lib/pastehub/clipboard.rb

@@ -43,7 +43,7 @@ module PasteHub
       nil
     end
 
-    def self.hasNew?( username )
+    def self.hasNew?( )
       Encoding.default_external = "UTF-8"
       str = Clipboard.paste( )
       str = str.force_encoding("UTF-8")

data/lib/pastehub/config.rb

@@ -43,107 +43,39 @@ module PasteHub
     end
 
     def initialize( )
-      self.setupServer( {} )
       self.setupClient( {} )
-      @listItems = 10
+      @verbose_flag = false
+      @notifyMessageMax = 80
     end
 
-    def setupServer( hash )
-      @aws                 = if hash[ :aws ]
-                               hash[ :aws ]
-                             else
-                               false
-                             end
-      @awsWarn             = if hash[ :awsWarn ]
-                               hash[ :awsWarn ]
-                             else
-                               false
-                             end
-      @dynamoEp            = if hash[ :dynamoEp ]
-                               hash[ :dynamoEp ]
-                             else
-                               dynamoEp = 'dynamodb.ap-northeast-1.amazonaws.com' # Default DynamoDB's endpoint is Tokyo Region
-                             end
-      @dynamoAccessKey     = if hash[ :dynamoAccessKey ]
-                               hash[ :dynamoAccessKey ]
-                             else
-                               "xxxx"
-                             end
-      @dynamoSecretKey     = if hash[ :dynamoSecretKey ]
-                               hash[ :dynamoSecretKey ]
-                             else
-                               "xxxx"
-                             end
-      @memcacheEp          = if hash[ :memcacheEp ]
-                               hash[ :memcacheEp ]
-                             else
-                               "localhost:11211"
-                             end
-      @keyCacheTime        = if hash[ :keyCacheTime ]
-                               hash[ :keyCacheTime ]
-                             else
-                               24 * 3600
-                             end
-      @domain              = if hash[ :domain ]
-                               hash[ :domain ]
-                             else
-                               "localhost"
-                             end
-      @keystore            = if hash[ :keystore ]
-                               hash[ :keystore ]
-                             else
-                               nil
-                             end
-      @keystorePassword    = if hash[ :keystorePassword ]
-                               hash[ :keystorePassword ]
-                             else
-                               "password"
-                             end
-    end
-
-    def appendSlash( uri )
-      if uri.match( /\/$/ )
-        uri
+    def getHomeDirectory( )
+      if ENV[ 'HOME' ]
+        return ENV[ 'HOME' ]
       else
-        uri + "/"
+        return "~/"
       end
     end
 
+    def setVerbose( verbose_flag )
+      @verbose_flag = verbose_flag
+    end
+    
+    def getVerbose( )
+      @verbose_flag
+    end
+
     def setupClient( hash )
-      @targetApiURL        = if hash[ :targetApiURL ]
-                               appendSlash( hash[ :targetApiURL ] )
-                             else
-                               "https://pastehub.net/api/"
-                             end
-      @targetNotifierURL   = if hash[ :targetNotifierURL ]
-                               appendSlash( hash[ :targetNotifierURL ] )
-                             else
-                               "https://pastehub.net:8001/"
-                             end
+
       @localDbPath         = if hash[ :localDbPath ]
                                hash[ :localDbPath ]
                              else
-                               File.expand_path( "~/.pastehub/" ) + "/"
+                               File.expand_path( sprintf( "%s/.pastehub/", getHomeDirectory() ))  + "/"
+                             end
+      @localSyncPath       = if hash[ :localSyncPath ]
+                               hash[ :localSyncPath ]
+                             else
+                               File.expand_path( sprintf( "%s/Dropbox/pastehub/", getHomeDirectory() )) + "/"
                              end
-   end
-
-    def loadServer()
-      name = "/etc/pastehub.conf"
-      if File.exist?( name )
-        open( name ) { |f|
-          json = JSON.parse( f.read )
-          self.setupServer( { :aws                => json[ 'aws' ],
-                              :awsWarn            => json[ 'awsWarn' ],
-                              :dynamoEp           => json[ 'dynamoEp' ],
-                              :dynamoAccessKey    => json[ 'dynamoAccessKey' ],
-                              :dynamoSecretKey    => json[ 'dynamoSecretKey' ],
-                              :memcacheEp         => json[ 'memcacheEp' ],
-                              :keyCacheTime       => json[ 'keyCacheTime' ],
-                              :domain             => json[ 'domain' ],
-                              :keystore           => json[ 'keystore' ],
-                              :keystorePassword   => json[ 'keystorePassword' ] } )
-        }
-      end
     end
 
     def loadClient()
@@ -151,16 +83,13 @@ module PasteHub
       if File.exist?( name )
         open( name ) { |f|
           json = JSON.parse( f.read )
-          self.setupClient( { :targetApiURL       => json[ 'targetApiURL' ],
-                              :targetNotifierURL  => json[ 'targetNotifierURL' ],
-                              :localDbPath        => json[ 'localDbPath' ] } )
-
+          self.setupClient( { :localDbPath        => json[ 'localDbPath' ],
+                              :localSyncPath      => json[ 'localSyncPath' ],
+                            } )
         }
       end
     end
 
-    attr_reader :aws, :dynamoEp, :dynamoAccessKey, :dynamoSecretKey, :memcacheEp, :keyCacheTime, :domain, :keystore, :keystorePassword
-    attr_reader :targetApiURL, :targetNotifierURL, :localDbPath, :listItems
-    attr_accessor :awsWarn
+    attr_reader :localDbPath, :localSyncPath, :notifyMessageMax
   end
 end