glima 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 27d1459f172ac0f758a2ee88cd5d99cb7f8b2daa
-  data.tar.gz: 933620cec4309b6ef67a6d845e3bd3adc6089b84
+  metadata.gz: ca5fd1499fa7dac5051d98341992248ebd7e22c7
+  data.tar.gz: 3e6ad81a9b119da5b82ad20be18af8ea66695cf2
 SHA512:
-  metadata.gz: f28c39166d7ba2f1ec4002140e2bb4a7120be0561334b38da9d63ab7ec02490abb2172f96b5646d03c3d23d458c02765d0cd76240ce674b01556e46a21a9e85f
-  data.tar.gz: 42c56a60f7cb35173827f1a91b50738cdddaed7db81bb796916bdf8cc5ff4335aeed1bff54b9458b257650301d4f5ee86e4623fa6a790777901bb9cac8cfc8d7
+  metadata.gz: d719e2648ab79c630701fc7d26c26e5f465ac454780f4954632a39df61a62da044ea5a8ea01a94ed36b1cec18c1fa31beb3fa32ed44bd0808bc94dff7409afdd
+  data.tar.gz: 3d3ccb2864a204932d77918fd650c81973402deec93588d0c04e8af6af895836a52986ecb9a97168e024a28f6fd01b6d5b43cf4c19e6f52f214b6ef0ad4f4da4

data/README.org

@@ -26,6 +26,13 @@
 
 * Installation
   Glima requires Ruby 2.3 or newer.
+
+** Install using gem
+  #+BEGIN_SRC sh
+    $ gem install glima
+  #+END_SRC
+
+** Install in sandbox
   It uses safe navigation operator (=&.=) introduced in Ruby 2.3.
 
   #+BEGIN_SRC sh
@@ -39,15 +46,46 @@
   #+END_SRC
 
 * Setup
-  #+BEGIN_SRC sh
-    # Create mail cache directory
-    $ mkdir -p ~/Mail/all
+  1) Get OAuth CLIENT_ID/CLIENT_SECRET
 
-    # Create config file
-    $ mkdir -p ~/.config/glima
-    $ cp examples/config_example.yml ~/.config/glima/config.yml
-    $ vi ~/.config/glima/config.yml
+     Visit https://console.developers.google.com and follow the instruction.
+     Googling 'Creating a Google API Console project and client ID' would help.
 
-    # Check your inbox
-    $ glima scan +inbox
-  #+END_SRC
+  2) Create app config file interactively
+     #+BEGIN_SRC sh
+       $ glima init
+
+       Creating ~/.config/glima/config.yml ...
+       Get your CLIENT_ID/CLIENT_SECRET at https://console.developers.google.com
+       Googling 'Creating a Google API Console project and client ID' would help.
+       CLIENT_ID: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.apps.googleusercontent.com
+       CLIENT_SECRET: xxxxxxxxxxxxxxxxxxxxxxxx
+       Gmail address: xxxxxxxxxxxxxxx@gmail.com
+
+       Making config directory ~/.config/glima ...
+             create  /Users/nom/.config/glima
+       Making cache directory ~/.cache/glima ...
+              exist  Ignore /Users/nom/.cache/glima
+       Copying file(s) into ~/.config/glima/config.yml ...
+              exist  Ignore ~/.config/glima
+                 ok  copy /Users/nom/.config/glima/config.yml
+       done.
+     #+END_SRC
+
+  3) Grant OAuth access to Gmail server (browser will be invoked)
+     #+BEGIN_SRC sh
+       $ glima auth
+
+       Authenticating xxxxxxxxxxxxxxx@gmail.com...
+       Enter the resulting code: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+     #+END_SRC
+     If you want to add another account, try ~glima auth --user=another_account~.
+
+  4) Check your inbox
+     #+BEGIN_SRC sh
+       $ glima scan +inbox
+
+       1 09/27 14:22 15ec1c9bd2c7f18d Hello....
+       2 09/27 14:00 15ec1b716bbb6bdc Yeah...
+       :
+     #+END_SRC

data/exe/axezip

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+
+# Usage: mail-finder mailfile.eml passwordish_mail_directory output_directory
+
+################################################################
+# rbenv support:
+# If this file is a symlink, and bound to a specific ruby
+# version via rbenv (indicated by RBENV_VERSION),
+# I want to resolve the symlink and re-exec
+# the original executable respecting the .ruby_version
+# which should indicate the right version.
+#
+if File.symlink?(__FILE__) and ENV["RBENV_VERSION"]
+  ENV["RBENV_VERSION"] = nil
+  shims_path = File.expand_path("shims", ENV["RBENV_ROOT"])
+  ENV["PATH"] = shims_path + ":" + ENV["PATH"]
+  exec(File.readlink(__FILE__), *ARGV)
+end
+
+gemfile = File.expand_path("../../Gemfile", __FILE__)
+
+if File.exists?(gemfile + ".lock")
+  ENV["BUNDLE_GEMFILE"] = gemfile
+  require "bundler/setup"
+end
+
+require "rubygems"
+require "date"
+require "mail"
+require "glima"
+require "logger"
+
+logger = ::Logger.new($stderr)
+logger.formatter = proc {|severity, datetime, progname, msg| "#{msg}\n"}
+
+Encoding.default_external="UTF-8"
+
+def find_nearby_mail(dir, &block)
+  if File.directory?(dir)
+    Dir.glob(File.expand_path('[0-9]*', dir)) do |eml|
+      header = File.open(eml, "rt") {|f| f.gets("")}
+      if header =~ /^Date: (.*)$/
+        begin
+          yield(eml, Date.parse($1))
+        rescue ArgumentError
+          nil
+        end
+      end
+    end
+  end
+end
+
+mail = Glima::Resource::Mail.read(ARGV.shift)
+hint = ARGV.shift
+directory = ARGV.shift || "~/Downloads/attachments"
+
+password_candidates = []
+
+begin
+  password_candidates += File.open(File.expand_path("~/.config/glima/passwords.txt")).read.strip.split("\n")
+rescue
+end
+
+find_nearby_mail(hint) do |eml, date|
+  if (mail.date - date).to_i.abs < 2
+    candidate = Glima::Resource::Mail.read(eml)
+    if candidate.from == mail.from
+      puts "#{date}: #{File.basename(eml)}: #{mail.from.first} #{mail.subject}"
+      password_candidates += candidate.find_passwordish_strings
+    end
+  end
+end
+
+# try to unlock zip attachments
+unless mail.unlock_zip!(password_candidates, logger)
+  puts "Password unlock failed."
+  exit 1
+end
+
+# Write to unlocked zip file to DIRECTORY
+mail.attachments.each do |attachment|
+  next unless attachment.filename =~ /\.zip$/i
+  zip_filename = File.expand_path(attachment.filename, directory)
+  Glima::Zip.new(attachment.body.decoded).write_to_file(zip_filename)
+  puts "Wrote to #{zip_filename || 'STDOUT'}."
+end

data/exe/glima

@@ -32,6 +32,12 @@ Encoding.default_external="UTF-8"
 
 class GlimaCLI < Clian::Cli
   package_name 'GLIMA'
+  remove_command :configuration
+
+  Signal.trap(:INT){
+    Thor.new.say "Interrupted quit.", :red
+    exit(0)
+  }
 
   ################################################################
   # global option
@@ -52,12 +58,13 @@ class GlimaCLI < Clian::Cli
   desc "auth", "Authenticate interactively"
 
   def auth
-    conf = config.general
-    authorizer = Clian::Authorizer.new(conf.client_id,
-                                       conf.client_secret,
-                                       Google::Apis::GmailV1::AUTH_SCOPE,
-                                       conf.token_store_path)
-    authorizer.auth_interactively(@user)
+    puts "Authenticating #{client.user}..."
+    begin
+      client.auth_interactively
+    rescue Glima::GmailClient::AuthorizationError
+      Thor.new.say "ERROR: authorization failed.", :red
+      exit(1)
+    end
   end
 
   ################################################################
@@ -68,6 +75,7 @@ class GlimaCLI < Clian::Cli
   method_option :zip_passwords_file, :desc => "Set additional password-list file."
 
   def dezip(gmail_id, directory)
+    @logger.info "Start"
     password_file = options[:password_file] || config.general.zip_passwords_file
     Glima::Command::Dezip.new(gmail_id, directory, password_file)
   end
@@ -100,8 +108,7 @@ class GlimaCLI < Clian::Cli
   expand_option :config
 
   def init
-    config_file = options[:config] || DEFAULT_CONFIG_PATH
-    Glima::Command::Init.new(config_file)
+    Glima::Command::Init.new(@config_path)
   end
 
   ################################################################
@@ -176,7 +183,7 @@ class GlimaCLI < Clian::Cli
   ################################################################
   # Command: scan
   ################################################################
-  desc "scan +FOLDER [QUERY]", "Scan FOLDER with QUERY."
+  desc "scan +LABEL [QUERY]", "Scan LABEL with QUERY."
 
   method_option :format, :desc => "Set printing format", :enum => %w(mew text archive)
 
@@ -220,18 +227,41 @@ class GlimaCLI < Clian::Cli
   ################################################################
   # Command: watch
   ################################################################
-  desc "watch [LABEL]", "Watch gmail server and xzip."
+  desc "watch QUEUE_LABEL MARK_LABEL", "Watch gmail server and xzip."
 
   def watch(queue_label, mark_label)
-    queue_label = parse_label_names(queue_label).first
-    mark_label  = parse_label_names(mark_label).first
-    Glima::Command::Watch.new(queue_label, mark_label)
+    default_passwords = []
+    password_file = options[:password_file] || config.general.zip_passwords_file
+    if File.exists?(File.expand_path(password_file))
+      default_passwords += File.open(File.expand_path(password_file)) {|f| f.read.split(/\n+/) }
+    end
+
+    error_count = 0
+    begin
+      ql = parse_label_names(queue_label).first
+      ml = parse_label_names(mark_label).first
+      timestamp = Time.now
+      Glima::Command::Watch.new(ql, ml, default_passwords)
+    rescue => err
+      @logger.info err
+      @logger.info err.backtrace
+      error_count += 1
+
+      # If Watch command lived longer than 60 seconds, it must have
+      # worked at least once.  So, reset error_count
+      error_count = 0 if Time.now - timestamp > 60
+
+      wait = 2 ** [error_count, 6].min
+      @logger.info "Waiting retry for #{wait} seconds."
+      sleep wait
+      retry
+    end
   end
 
   ################################################################
   # Command: xzip
   ################################################################
-  desc "xzip TARGET", "Transform zip-attachments in TARGET and transmit to Gmail."
+  desc "xzip TARGET", "Transform zip-attachments in TARGET and push back to Gmail."
 
   method_option :add_src_labels, :desc => "Add labels to source",        :banner => "LABEL,..."
   method_option :add_dst_labels, :desc => "Add labels to destination",   :banner => "LABEL,..."
@@ -239,7 +269,14 @@ class GlimaCLI < Clian::Cli
   method_option :del_dst_labels, :desc => "Del labels from destination", :banner => "LABEL,..."
 
   def xzip(target)
-    Glima::Command::Xzip.new(target,
+    default_passwords = []
+
+    password_file = options[:password_file] || config.general.zip_passwords_file
+    if File.exists?(password_file)
+      default_passwords += File.open(password_file) {|f| f.read.split(/\n+/) }
+    end
+
+    Glima::Command::Xzip.new(target, default_passwords,
                              add_src_labels: parse_label_names(options[:add_src_labels]),
                              del_src_labels: parse_label_names(options[:del_src_labels]),
                              add_dst_labels: parse_label_names(options[:add_dst_labels]),
@@ -265,47 +302,49 @@ class GlimaCLI < Clian::Cli
     end
   end
 
-  attr_reader :builder, :config, :user, :context
+  attr_reader :builder, :config, :user, :context, :client
 
   def setup_global_options(command, *args)
     exit_on_error do
-      @config = Glima::Config.create_from_file(options[:config] || DEFAULT_CONFIG_PATH) unless command.name == "init"
-      @datastore = Glima::DataStore.new(File.expand_path("~/Mail"))
-      @user   = options[:user] || config.general.default_user
-      @context = Glima::Context.new(File.expand_path(DEFAULT_CONFIG_HOME))
-
-      logger = ::Logger.new($stderr)
-      logger.formatter = proc {|severity, datetime, progname, msg| "#{msg}\n"}
-
-      Glima::Command.client = client unless command.name == "auth"
-      Glima::Command.logger = logger
-      # Glima::GmailClient.logger = logger
-
       if options[:profile]
         require 'profiler'
         Profiler__.start_profile
       end
+
       if options[:debug]
         require "pp"
         $GLIMA_DEBUG = true
         $GLIMA_DEBUG_FOR_DEVELOPER = true if ENV["GLIMA_DEBUG_FOR_DEVELOPER"]
       end
-    end
-  end
 
-  def client
-    begin
-      @client ||= Glima::GmailClient.new(config.general, @user, @datastore)
-    rescue Glima::GmailClient::AuthorizationError
-      STDERR.print "Authorization Error: try ``glima auth'' command.\n"
-      exit(1)
-    end
-  end
-end
+      @logger = ::Logger.new($stderr)
+      @logger.formatter = proc {|severity, datetime, progname, msg| "#{datetime} #{msg}\n"}
+      Glima::Command.logger = @logger
+
+      @config_path = options[:config] || DEFAULT_CONFIG_PATH
 
-def teardown
-  if options[:profile]
-    Profiler__.print_profile($stdout)
+      return true if ["init", "help"].member?(command.name)
+
+      @config = Glima::Config.create_from_file(@config_path)
+      @datastore = Glima::DataStore.new(File.expand_path(config.general.cache_directory))
+      @user  = options[:user] || config.general.default_user
+      @context = Glima::Context.new(File.expand_path(DEFAULT_CONFIG_HOME))
+      @client = Glima::GmailClient.new(config.general.client_id,
+                                       config.general.client_secret,
+                                       File.expand_path("token_store.yml", File.dirname(@config_path)),
+                                       @user, @datastore, @logger)
+
+      Glima::Command.client = @client
+
+      unless ["auth"].member?(command.name)
+        begin
+          @client.auth
+        rescue Glima::GmailClient::AuthorizationError
+          Thor.new.say "ERROR: access token expired? try: glima auth --user=#{@user}", :red
+          exit(1)
+        end
+      end
+    end
   end
 end
 

data/lib/glima/command/dezip.rb

@@ -15,13 +15,16 @@ module Glima
 
         # get password candidates from config file
         password_candidates = []
+        password_file = File.expand_path(password_file)
         if File.exists?(password_file)
           password_candidates += File.open(password_file) {|f| f.read.split(/\n+/) }
         end
 
         # gather password candidates from nearby mails
+        index = 0
         client.nearby_mails(mail) do |nm|
-          logger.info "Passwordish mail: " + nm.format_summary
+          index += 1
+          logger.info "Passwordish mail(#{index}): " + nm.format_summary
           password_candidates += nm.find_passwordish_strings
         end
 

data/lib/glima/command/init.rb

@@ -22,14 +22,19 @@ module Glima
         config[:client_id] = @shell.ask "CLIENT_ID:"
         config[:client_secret] = @shell.ask "CLIENT_SECRET:"
         config[:default_user] = @shell.ask "Gmail address:"
-        config[:token_store_path] = File.expand_path("token_store.yml", config_dir)
+        config[:cache_directory] = "~/.cache/glima"
 
-        # mkdir
+        # mkdir config_dir
         unless Dir.exist?(File.expand_path(config_dir))
           say "Making config directory #{config_dir} ..."
           mkdir_p(File.expand_path(config_dir))
         end
 
+        # mkdir cache_dir
+        cache_dir = config[:cache_directory]
+        say "Making cache directory #{cache_dir} ..."
+        mkdir_p(File.expand_path(cache_dir))
+
         # make config file from tamplate
         say "Copying file(s) into #{config_file} ..."
         src = File.expand_path("config.yml.erb", TEMPLATE_DIR)
@@ -79,15 +84,15 @@ module Glima
       end
 
       def mkdir_p(path)
-        path = File.expand_path(path)
+        abspath = File.expand_path(path)
 
-        if File.directory?(path)
+        if File.directory?(abspath)
           say_status "exist", "Ignore #{path}", :yellow
           return
         end
 
         begin
-          FileUtils.mkdir_p(path)
+          FileUtils.mkdir_p(abspath)
           say_status "create", "#{path}", :green
         rescue StandardError => e
           say_status "failed", "#{e.message.split(' @').first} #{path}", :red

data/lib/glima/command/watch.rb

@@ -2,42 +2,49 @@ module Glima
   module Command
     class Watch < Base
 
-      def initialize(queue_label = nil, mark_label = nil)
+      def initialize(queue_label = nil, mark_label = nil, default_passwords = [])
+        # If xzip is successful,
+        #   remove queue_label from the original message, also
+        #   add mark_label to the xzipped message.
+        #
+        add_labels, del_labels = [], []
+        add_labels << mark_label  if mark_label
+        del_labels << queue_label if queue_label
+
+        # if queue_label is set, xzip process scan search zip-attached
+        # messages with queue_label, without mark_label
+        #
+        if queue_label
+          target = "label:#{queue_label.name}"
+          target += " -label:#{mark_label.name}" if mark_label
+        end
+
+        # Cleanup queue before watching imap events.
+        logger.info "xzip cleanup queue before watching imap events #{target}."
+        Glima::Command::Xzip.new(target, default_passwords,
+                                 add_dst_labels: add_labels,
+                                 del_dst_labels: del_labels,
+                                 del_src_labels: del_labels)
 
         # Watch "[Gmail]/All Mail" by IMAP idle
-        client.watch(nil) do |ev|
-          next unless ev.type == :added
-
-          # Scan messages in queue_label or new message itself.
-          #
-          # If Xzip process is successful, remove queue_label
-          # from the source message.
-          #
-          if queue_label
-            target      = "label:#{queue_label.name}"
-            target     += " -label:#{mark_label.name}" if mark_label
-            del_labels  = [queue_label]
-          else
-            target      = ev.message.id
-            del_labels  = []
-          end
-
-          # Also, mark_label will be added to the xzipped message.
-          # It is for avoidance of infinite loop.
-          #
-          if mark_label
-            add_labels = [mark_label]
-          else
-            add_labels = []
-          end
-
-          logger.info "Xzip #{target}"
-
-          Glima::Command::Xzip.new(client, logger, target,
+
+        timestamp = Time.now
+
+        logger.info "[#{self.class}#initialize] Entering GmailClient#watch"
+        client.watch do |ev|
+          # avoid burst events
+          next if Time.now - timestamp < 3
+
+          logger.info "[#{self.class}#initialize] xzip #{target} in event loop."
+
+          target ||= ev.message.id
+          Glima::Command::Xzip.new(target, default_passwords,
                                    add_dst_labels: add_labels,
                                    del_dst_labels: del_labels,
                                    del_src_labels: del_labels)
+          timestamp = Time.now
         end
+        logger.info "[#{self.class}#initialize] Done (not reached)"
       end
 
     end # class Watch

data/lib/glima/command/xzip.rb

@@ -1,7 +1,7 @@
 module Glima
   module Command
     class Xzip < Base
-      def initialize(target,
+      def initialize(target, default_passwords,
                      add_src_labels: [],
                      del_src_labels: [],
                      add_dst_labels: [],
@@ -20,15 +20,22 @@ module Glima
 
         ids.each do |message_id|
           # get target mail
+          logger.info "xzip start #{message_id}"
+
           mail = client.get_user_smart_message(message_id) do |m, err|
             if err
-              puts "Error: #{err}"
+              logger.error "Error: #{err}"
               next
             end
           end
 
+          unless mail.attachments.map(&:filename).any? {|filename| filename =~ /\.zip$/i}
+            logger.info "xzip skip #{message_id} - has no zip attachments"
+            next
+          end
+
           # find password candidates from nearby mails
-          password_candidates = []
+          password_candidates = default_passwords || []
           client.nearby_mails(mail) do |nm|
             logger.info "Passwordish mail: " + nm.format_summary
             password_candidates += nm.find_passwordish_strings
@@ -36,13 +43,13 @@ module Glima
 
           # try to unlock zip attachments
           unless mail.unlock_zip!(password_candidates, logger)
-            puts "Password unlock failed."
+            logger.info "Password unlock failed."
             next
           end
 
           # push back unlocked mail to server
           unless push_mail(mail, "dateHeader", add_dst_label_ids, del_dst_label_ids)
-            puts "Push mail failed."
+            logger.info "Push mail failed."
             next
           end
 
@@ -59,9 +66,9 @@ module Glima
 
           client.modify_message('me', message_id, req) do |res,err|
             if res
-              puts "Update #{message_id} successfully."
+              logger.info "[#{self.class}#initialize] Update #{message_id} successfully."
             else
-              puts "Error: #{err}"
+              logger.info "[#{self.class}#initialize] Error: #{err}"
             end
           end
         end
@@ -89,10 +96,10 @@ module Glima
           internal_date_source: date_source,
           upload_source: StringIO.new(mail.to_s)) do |msg, err|
           if msg
-            puts "pushed to: #{msg.id}"
+            logger.info "[#{self.class}#push_mail] pushed to: #{msg.id}"
             return true
           else
-            STDERR.puts "Error: #{err}"
+            logger.info "[#{self.class}#push_mail] Error: #{err}"
             return false
           end
         end

data/lib/glima/config.rb

@@ -4,8 +4,7 @@ module Glima
     class General < Clian::Config::Element
       define_syntax :client_id => String,
                     :client_secret => String,
-                    :token_store_path => String,
-                    :context_store => String,
+                    :cache_directory => String,
                     :zip_passwords_file => String,
                     :default_user => String
     end # class General

data/lib/glima/datastore.rb

@@ -8,7 +8,12 @@ module Glima
       unless basedir and File.directory?(File.expand_path(basedir.to_s))
         raise Glima::ConfigurationError, "datastore directory '#{basedir}' not found"
       end
+
       @basedir = Pathname.new(File.expand_path(basedir))
+
+      unless Dir.exist?(dir = File.expand_path("all", @basedir))
+        FileUtils.mkdir_p(dir)
+      end
     end
 
     def update(message)

data/lib/glima/gmail_client.rb

@@ -11,14 +11,6 @@ module Glima
   class GmailClient
     class AuthorizationError < StandardError ; end
 
-    def self.logger
-      Google::Apis.logger
-    end
-
-    def self.logger=(logger)
-      Google::Apis.logger = logger
-    end
-
     extend Forwardable
 
     def_delegators :@client,
@@ -43,6 +35,7 @@ module Glima
     # Users getProfile
     :get_user_profile
 
+    attr_reader :user
 
     # Find nearby messages from pivot_message
     # `Nearby' message:
@@ -92,40 +85,53 @@ module Glima
       }.map(&:addr).map(&:ip_address).length > 0
     end
 
-    def initialize(config, user, datastore)
-      authorizer = Clian::Authorizer.new(config.client_id,
-                                  config.client_secret,
-                                  Google::Apis::GmailV1::AUTH_SCOPE,
-                                  config.token_store_path)
-
-      unless credentials = authorizer.credentials(user)
-        raise AuthorizationError.new
-      end
-
+    def initialize(client_id, client_secret, token_store_path, user, datastore, logger = nil)
+      @client_id = client_id
+      @client_secret = client_secret
+      @token_store_path = token_store_path
+      @user = user
       @datastore = datastore
       @client = Google::Apis::GmailV1::GmailService.new
       @client.client_options.application_name = 'glima'
-      @client.authorization = credentials
-      @client.authorization.username = user # for IMAP
+      if logger
+        @logger = logger
+      else
+        # quiet
+        @logger = ::Logger.new($stderr)
+        @logger.formatter = proc {|severity, datetime, progname, msg| ""}
+      end
+    end
 
-      return @client
+    def auth_interactively
+      credentials = begin
+                      authorizer.auth_interactively(@user)
+                    rescue
+                      raise AuthorizationError.new
+                    end
+      @client.authorization = credentials
+      @client.authorization
+      @client.authorization.username = @user # for IMAP
     end
 
-    # label == nil means "[Gmail]/All Mail"
-    def wait(label = nil)
-      @imap ||= Glima::ImapWatch.new("imap.gmail.com", @client.authorization)
-      @imap.wait(label&.name)
+    def auth
+      unless credentials = authorizer.credentials(@user)
+        raise AuthorizationError.new
+      end
+      @client.authorization = credentials
+      @client.authorization.username = @user # for IMAP
     end
 
     def watch(label = nil, &block)
       loop do
-        puts "tick"
+        @logger.info "[#{self.class}#watch] loop tick"
 
         curr_hid = get_user_profile(me).history_id.to_i
         last_hid ||= curr_hid
 
-        # FIXME: if server is changed at this point, we will miss the event.
-        wait(label) if last_hid == curr_hid
+        # If server is changed at this point, we will miss the events.
+        # so, we have to set the timeout and update history record.
+
+        wait(label, 60) if last_hid == curr_hid
 
         each_events(since: last_hid) do |ev|
           yield ev
@@ -214,6 +220,15 @@ module Glima
 
     private
 
+    def authorizer
+      @authorizer ||= Clian::Authorizer.new(
+        @client_id,
+        @client_secret,
+        Google::Apis::GmailV1::AUTH_SCOPE,
+        @token_store_path
+      )
+    end
+
     def me
       'me'
     end
@@ -236,5 +251,26 @@ module Glima
       end
     end
 
+    # label == nil means "[Gmail]/All Mail"
+    def wait(label = nil, timeout_sec = 60)
+      @logger.info "[#{self.class}#wait] Enter"
+
+      if @imap.nil? || @imap.disconnected?
+        @imap = Glima::ImapWatch.new("imap.gmail.com", @client.authorization, @logger)
+
+        @logger.debug "[#{self.class}#wait] create new IMAPWatch #{@imap}"
+      else
+        @logger.debug "[#{self.class}#wait] use existing IMAPWatch #{@imap}"
+      end
+
+      begin
+        @imap.wait(label&.name, timeout_sec)
+      rescue
+        @imap = nil
+        @logger.info "[#{self.class}#wait] imap connection error. abandon current imap connection."
+      end
+      @logger.info "[#{self.class}#wait] Exit"
+    end
+
   end # class GmailClient
 end # module Glima

data/lib/glima/imap.rb

@@ -3,6 +3,10 @@ require "net/imap"
 require "pp"
 
 module Glima
+  #
+  # IMAP client with IMAP extentions provided by Gmail
+  #   https://developers.google.com/gmail/imap/imap-extensions
+  #
   class IMAP < Net::IMAP
     def initialize(host, port_or_options = {},
                    usessl = false, certs = nil, verify = true)
@@ -86,33 +90,16 @@ module Glima
     def_delegators :@imap,
     :fetch,
     :select,
-    :disconnect
+    :disconnected?
 
-    def initialize(imap_server, authorization)
+    def initialize(imap_server, authorization, logger)
+      @imap_server, @authorization, @logger = imap_server, authorization, logger
       connect(imap_server, authorization)
     end
 
-    def watch(folder, &block)
-      @imap.select(Net::IMAP.encode_utf7(folder))
+    def wait(folder = nil, timeout_sec = 60)
+      logger.info "[#{self.class}#wait] Enter"
 
-      @thread = Thread.new do
-        while true
-          begin
-            @imap.idle do |resp|
-              yield resp if resp.name == "EXISTS"
-            end
-          rescue Net::IMAP::Error => e
-            if e.inspect.include? "connection closed"
-              connect
-            else
-              raise
-            end
-          end
-        end
-      end
-    end
-
-    def wait(folder = nil)
       if folder
         folder = Net::IMAP.encode_utf7(folder)
       else
@@ -122,84 +109,46 @@ module Glima
 
       @imap.select(folder)
       begin
-        @imap.idle do |resp|
-          puts "#{resp.name}"
-          @imap.idle_done # if resp.name == "EXISTS"
-        end
-      rescue Net::IMAP::Error => e
-        if e.inspect.include? "connection closed"
-          connect
-        else
-          raise
-        end
-      end
-    end
-
-    # Ruby IMAP IDLE concurrency - how to tackle? - Stack Overflow
-    # http://stackoverflow.com/questions/5604480/ruby-imap-idle-concurrency-how-to-tackle
-    # How bad is IMAP IDLE? Joshua Tauberer's Archived Blog
-    # https://joshdata.wordpress.com/2014/08/09/how-bad-is-imap-idle/
-    #
-    def watch_and_fetch(folder, &block)
-      @imap.select(folder)
-      num = @imap.responses["EXISTS"].last
-
-      last_uid = @imap.fetch(num, "UID").first.attr['UID']
-      puts "Last_UID: #{last_uid}"
-
-      while true
-        id = waitfor()
-
-        puts "*********** GET EXISTS: #{id}"
-        mails = @imap.uid_fetch(last_uid..-1, %w(UID X-GM-MSGID X-GM-THRID X-GM-LABELS))
-
-        mails.each do |mail|
-          next if mail.attr['UID'] <= last_uid
-          resp  = yield mail
-          return unless resp
+        th = Thread.new(@imap, timeout_sec) do |imap, timeout|
+          begin
+            sleep timeout
+          ensure
+            imap.idle_done
+          end
         end
 
-        last_uid = mails.last.attr['UID']
-      end
-    end
-
-    private
-
-    def waitfor
-      id = -1
-      begin
         @imap.idle do |resp|
-          pp resp
-          if resp.name == "EXISTS"
-            @imap.idle_done
-            id = resp.data.to_i
-          else
-            # pp resp
-          end
+          logger.info "[#{self.class}#wait] got event #{resp.name} in IMAP IDLE"
+          th.terminate
         end
       rescue Net::IMAP::Error => e
         if e.inspect.include? "connection closed"
-          connect
+          reconnect
         else
           raise
         end
       end
-      return id
-    end
+      logger.info "[#{self.class}#wait] Exit"
+    end # def wait
+
+    private
 
     def connect(imap_server, authorization)
+      logger.info "[#{self.class}#connect] Enter"
       retry_count = 0
 
       begin
-        username     = authorization.username
-        access_token = authorization.access_token
-
         @imap = Glima::IMAP.new(imap_server, 993, true)
-        @imap.authenticate('XOAUTH2', username, access_token)
-        puts "connected to imap server #{imap_server}."
+        @imap.authenticate('XOAUTH2',
+                           authorization.username,
+                           authorization.access_token)
+        logger.info "[#{self.class}#connect] connected"
 
       rescue Net::IMAP::NoResponseError => e
+        logger.info "[#{self.class}#connect] rescue Net::IMAP::NoResponseError => e"
+
         if e.inspect.include? "Invalid credentials" && retry_count < 2
+          logger.info "[#{self.class}#connect] Refreshing access token for #{imap_server}."
           authorization.refresh!
           retry_count += 1
           retry
@@ -207,13 +156,18 @@ module Glima
           raise
         end
       end
+      logger.info "[#{self.class}#connect] Exit"
+    end
+
+    def reconnect
+      logger.info "[#{self.class}#reconnect] Enter"
+      connect(@imap_server, @authorization)
+      logger.info "[#{self.class}#reconnect] Exit"
+    end
+
+    def logger
+      @logger
     end
 
-    # def connect(imap_server, user_name, access_token)
-    #   @imap = Glima::IMAP.new(imap_server, 993, true)
-    #   # @imap.class.debug = true
-    #   @imap.authenticate('XOAUTH2', user_name, access_token)
-    #   puts "connected to imap server #{imap_server}."
-    # end
   end # class ImapWatch
 end # module Glima

data/lib/glima/resource/mail.rb

@@ -79,7 +79,7 @@ module Glima
       end
 
       def format_summary(count = nil)
-        date = Time.at(internal_date.to_i/1000).strftime("%m/%d %H:%M")
+        date = Time.at(internal_date.to_i/1000).strftime("%Y/%m/%d %H:%M")
         count = if count then ("%4d " % count) else "" end
         return "#{count}#{date} #{id} #{CGI.unescapeHTML(snippet)[0..30]}"
       end

data/lib/glima/templates/config.yml.erb

@@ -3,5 +3,6 @@ GENERAL:
 ################################################################
   CLIENT_ID: "<%= config[:client_id] %>"
   CLIENT_SECRET: "<%= config[:client_secret] %>"
-  TOKEN_STORE_PATH: "<%= config[:token_store_path] %>"
   DEFAULT_USER: "<%= config[:default_user] %>"
+  CACHE_DIRECTORY: "<%= config[:cache_directory] %>"
+# ZIP_PASSWORDS_FILE: "~/.config/glima/passwords.txt"

data/lib/glima/version.rb

@@ -1,3 +1,3 @@
 module Glima
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

data/lib/glima/zip.rb

@@ -38,8 +38,8 @@ module Glima
     def unlock_password!(password_candidates, logger = nil)
       list = sort_by_password_strength(password_candidates.uniq).unshift("")
 
-      list.each do |password|
-        msg = "Try password:'#{password}' (#{password_strength(password)})..."
+      list.each_with_index do |password, i|
+        msg = "Try password(#{i}):'#{password}' (#{password_strength(password)})..."
 
         if correct_password?(password)
           logger.info(msg + " OK.") if logger
@@ -100,7 +100,7 @@ module Glima
       password = password.to_s
       score = Math.log2(password.length + 1)
 
-      password.scan(/[a-z]+|[A-Z]+|\d+|[!"#$%&'()*+,-.\/:;<=>?@\[\\\]^_`{|}~]+/) do |s|
+      password.scan(/[A-Z]?[a-z]+|[A-Z]+|[-+\d]+|[!"#$%&'()*+,-.\/:;<=>?@\[\\\]^_`{|}~]+/) do |s|
         score += 1.0
       end
       return score

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glima
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Yoshinari Nomura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-09-26 00:00:00.000000000 Z
+date: 2017-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -112,6 +112,7 @@ description: Gmail CLI client
 email:
 - nom@quickhack.net
 executables:
+- axezip
 - glima
 extensions: []
 extra_rdoc_files: []
@@ -125,7 +126,7 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
-- examples/config_example.yml
+- exe/axezip
 - exe/glima
 - glima.gemspec
 - lib/glima.rb

data/examples/config_example.yml

@@ -1,8 +0,0 @@
-################################################################
-GENERAL:
-################################################################
-  CLIENT_ID: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.apps.googleusercontent.com"
-  CLIENT_SECRET: "yyyyyyyyyyyyyyyyyyyyyyyy"
-  TOKEN_STORE: "/Users/nom/.config/glima/token_store.yml"
-  CONTEXT_STORE_PATH: "/Users/nom/.config/glima/context.yml"
-  DEFAULT_USER: "????????@gmail.com"