ad583255925 (5832)

部署的时候，有时候会卡在 Resolving dependencies...，明明 Gemfile 和 lock 都没动

ad583255925 — Thu, 17 Oct 2024 10:58:17 +0800

-----> Symlinking shared paths Fetching source index from https://gems.ruby-china.com/ Resolving dependencies...

自己部署的 Sentry，CSRF

ad583255925 — Thu, 11 Jan 2024 19:12:10 +0800

sentry.io 不知道为什么隔一段时间服务器就没法访问了，会一直 timeout，所以只能自己搭，找的 docker hub 里的第一个 https://hub.docker.com/_/sentry

按照步骤装完了，我跑在了服务器的 8090，用 nginx 映射到他，然后顺利跑起来了

奇怪的是，我把这个 DSN 配到项目里去之后，就一直报跨域

求大神支招，甚至推荐其他可用的错误日志拼台也行

有没有用 Rails + filebeat + ELK 作为日志分析平台的，我想求一套配置拆解 Rails 日志的

ad583255925 — Tue, 07 Nov 2023 19:06:22 +0800

想求一套作业：按照请求 ID 合并日志

服务器 bundle install 又出现 Bundler::Fetcher::CertificateFailureError

ad583255925 — Wed, 01 Mar 2023 21:16:31 +0800

服务器是 centos7，ruby 版本为 2.7.1，尝试重新安装了，没用，怀疑是 openssl 版本太老，于是从 1.0.x 升到了 1.1.x，还是没用，有一点比较奇怪，我尝试运行了以下命令

openssl s_client -showcerts -connect gems.ruby-china.com:443 -servername gems.ruby-china.com

在 openssl 没升级上来之前，会报一个证书过期的错误，然而升级到 1.1.1 之后，会出现下面的错误

...
Verify return code: 20 (unable to get local issuer certificate)

看起来像是我机器的证书链不全？但是如果指定 CAfile 是正确的

openssl s_client -showcerts -connect gems.ruby-china.com:443 -servername gems.ruby-china.com -CAfile /etc/pki/tls/certs/ca-bundle.crt

这样看起来是没问题的，总之为了解决一个错误，感觉越走越偏了，有人碰到过类似的问题么。

在力扣做的一道题，相当之诡异

ad583255925 — Wed, 23 Oct 2019 22:33:01 +0800

https://leetcode-cn.com/problems/next-permutation/

实现获取下一个排列的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。

如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。

必须原地修改，只允许使用额外常数空间。

以下是一些例子，输入位于左侧列，其相应输出位于右侧列。
1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/next-permutation
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

我的答案

# @param {Integer[]} nums
# @return {Void} Do not return anything, modify nums in-place instead.
def next_permutation(nums)
    result = nums.sort.dup
    (0..nums.length - 1).reverse_each do |i|
        if nums[i - 1] && nums[i] > nums[i - 1]
            ex_num = nums[i..-1].sort.find {|n| n > nums[i-1] }
            ex_index = nums.index.with_index {|n, j| j > i - 1 && n == ex_num} 
            nums[i-1], nums[ex_index] = nums[ex_index], nums[i-1]
            result = (nums[0..i-1] + nums[i..-1].sort).dup
            break
        end    
    end    
    result
end

我自己控制台跑 [1, 3, 2] 的时候，没问题，会返回[2, 1, 3]，但是力扣永远给我输出[2,3,1]，我在返回结果前的最后一行也打印了结果，确实是[2,1,3]，不知道力扣用的哪个版本的 ruby，望各位帮忙也跑一下，看看结果，谢谢

next_permutation([1,3,2])

Rails 里面使用 jwt_token 来鉴权

ad583255925 — Mon, 30 Sep 2019 14:39:30 +0800

简介

前后端分离之后，关于鉴权方式的选择里，除了传统的使用 session 之外，还可以使用 jwt_token 来鉴权，尤其是手机端的项目，使用 jwt_token 鉴权有以下好处

前端会比较好处理，因为 session 一般是装在 cookies 里面，如果要持久化登录的话，对于前端来说拼接 cookie 会额外带来一些工作，而 jwt_token 采用自己的独有的 header
服务端不用维护 session 服务器了，这节省了非常多的开销

大致原理

流程

在前端登录成功后，会把 jwt_token 返回给前端，而前端之后每次访问都会在 header 里面加一条 (Authorization: Bearer XXXX)，XXXX 就是放置 jwt_token 的位置

jwt_token 结构

详细的结构可以看这里，我这里就简单的概括一下 jwt 分为三段

Header，声明该 token 的加密方式
payload，主体信息全在这里，你可以在这里控制该用户的登录期限
验签，把第一部分和第二部分通过服务器的私钥加密，变成第三段

三段数据全部用 Base64 加密，然后用.来隔开，就生成了 jwt_token，一般会长这样

eyJhbGciOiJIUzI1NiJ9.eyJleHBfYXQiOiIyMDE5LTEwLTA2IDE3OjU3OjU0ICswODAwIiwiaWQiOjQsInVzZXJuYW1lIjoi57qq5Lqa55Cq77yI6LaF566h77yJIiwidXNlcl90eXBlIjoic3VwZXJfYWRtaW4iLCJtb2JpbGUiOiIxNzcyMTI3MzIzMyJ9.38VDrWZlDmAY4fiYmJo-_rDKhYzaxEwiewj9ruyVSCQ

安全性

该 token 的安全保障其实全靠那个私钥（其实基于 https 完全不用考虑安全问题），当前端试图更改 payload 信息来登录其他账号时，由于他不知道对称加密要用到的私钥，因此他无法生成正确的第三段信息，因此他无法通过服务器的验证

在 Rails 里面使用 jwt_token

安装 gem

gem 'jwt'

$ bundle install

写生成 token 和验证 token 的方法

可以放在 user 模型里，这个随意生成 jwt_token 的方法 user.rb

class User < ApplicationRecord
  def generate_jwt_token
    hmac_secret = JWT_HMAC_SECRET ##服务器的私钥，可以是一个字符串或者钥匙，这个自己决定
    payload = {
      exp_at: (Time.now + 1.week).to_s,
      id: id,
      username: username,
      user_type: user_type,
      mobile: mobile
    }
    JWT.encode payload, hmac_secret, 'HS256'
  end
...

验证方法

def self.decoded_jwt_infos token
  JWT.decode(token, JWT_HMAC_SECRET, true, { algorithm: 'HS256' })[0]
end

在控制器层，写 current_user 方法

class Api::ApiController < ApplicationController
  skip_before_action :verify_authenticity_token

  def check_login
    if current_user.blank?
      render json: {msg: "登录失败", result: false}, status: :forbidden
    end
  end

  def current_user
    if request.headers['Authorization']&.start_with?("Bearer")
      jwt_token = request.headers['Authorization'].split&.last
      jwt_info = User.decoded_jwt_infos(jwt_token)
      if Time.parse(jwt_info["exp_at"]) > Time.now
        @current_user ||= User.unscoped.active.find_by_id(jwt_info["id"])
      end
    end
  rescue JWT::ExpiredSignature, JWT::VerificationError
    nil
  end

end

剩下的就是在登录成功后将生成的 token 返回，可以放在 body 里，也可以放在 headers 里，这个随意

[搬运] 23 个例子让你彻底搞定 Elasticsearch 的搜索查询语法

ad583255925 — Sun, 21 Apr 2019 14:26:36 +0800

原文 https://dzone.com/articles/23-useful-elasticsearch-example-queries

为了说明 Elasticsearch 里不同的搜索类型，我们将会搜索一张名为 book 的表，并且拥有以下几个字段：title, authors, summary, release, data 和 number of reviews

首先我们将使用bulk API来准备一些测试数据

PUT /bookdb_index
    { "settings": { "number_of_shards": 1 }}

POST /bookdb_index/book/_bulk
    { "index": { "_id": 1 }}
    { "title": "Elasticsearch: The Definitive Guide", "authors": ["clinton gormley", "zachary tong"], "summary" : "A distibuted real-time search and analytics engine", "publish_date" : "2015-02-07", "num_reviews": 20, "publisher": "oreilly" }
    { "index": { "_id": 2 }}
    { "title": "Taming Text: How to Find, Organize, and Manipulate It", "authors": ["grant ingersoll", "thomas morton", "drew farris"], "summary" : "organize text using approaches such as full-text search, proper name recognition, clustering, tagging, information extraction, and summarization", "publish_date" : "2013-01-24", "num_reviews": 12, "publisher": "manning" }
    { "index": { "_id": 3 }}
    { "title": "Elasticsearch in Action", "authors": ["radu gheorge", "matthew lee hinman", "roy russo"], "summary" : "build scalable search applications using Elasticsearch without having to do complex low-level programming or understand advanced data science algorithms", "publish_date" : "2015-12-03", "num_reviews": 18, "publisher": "manning" }
    { "index": { "_id": 4 }}

例子

最基础的 match query

有两种方法可以执行一个基础的 full-text 查询：使用轻量的 Search Api，这种方式通过在 Url 中加入参数来进行简单的查询，或者通过 JSON 格式的 request body，这种方式可以使用完整的 Elasticsearch 搜索 DSL

这是一个基础的查询，搜索所有字段，匹配字符“guide”

GET /bookdb_index/book/_search?q=guide
[Results]
"hits": [
  {
    "_index": "bookdb_index",
    "_type": "book",
    "_id": "4",
    "_score": 1.3278645,
    "_source": {
      "title": "Solr in Action",
      "authors": [
        "trey grainger",
        "timothy potter"
      ],
      "summary": "Comprehensive guide to implementing a scalable search engine using Apache Solr",
      "publish_date": "2014-04-05",
      "num_reviews": 23,
      "publisher": "manning"
    }
  },
  {
    "_index": "bookdb_index",
    "_type": "book",
    "_id": "1",
    "_score": 1.2871116,
    "_source": {
      "title": "Elasticsearch: The Definitive Guide",
      "authors": [
        "clinton gormley",
        "zachary tong"
      ],
      "summary": "A distibuted real-time search and analytics engine",
      "publish_date": "2015-02-07",
      "num_reviews": 20,
      "publisher": "oreilly"
    }
  }
]

下面是使用 DSL 的版本，和上面的效果相同

GET /bookdb_index/book/_search

{
    "query": {
        "multi_match" : {
            "query" : "guide",
            "fields" : ["title", "authors", "summary", "publish_date", "num_reviews", "publisher"]
        }
    }
}

multi_match关键字的作用是可以使多个字段同时匹配一个关键字，fields属性声明需要查询哪些字段，在这个例子中，我们搜索了这张表的所有字段

备注：Elasticsearch6 之前的版本可以使用"_all"，来代替你声明所有字段，"_all"字段的原理是串联所有的字段到一个大的字段，并使用空格分割，然后再分析并索引字段，从 Elasticsearch6 开始，这个功能将被弃用，Elasticsearch6 提供了"copy_to"参数，你可以利用这个创建自定义的"_all"字段，查看Guide获取更多信息

Url 的搜索方式也允许你声明你想要搜索的字段，比如，搜索 title 为“in Action”的 books

GET /bookdb_index/book/_search?q=title:in action
[Results]
"hits": [
  {
    "_index": "bookdb_index",
    "_type": "book",
    "_id": "3",
    "_score": 1.6323128,
    "_source": {
      "title": "Elasticsearch in Action",
      "authors": [
        "radu gheorge",
        "matthew lee hinman",
        "roy russo"
      ],
      "summary": "build scalable search applications using Elasticsearch without having to do complex low-level programming or understand advanced data science algorithms",
      "publish_date": "2015-12-03",
      "num_reviews": 18,
      "publisher": "manning"
    }
  },
  {
    "_index": "bookdb_index",
    "_type": "book",
    "_id": "4",
    "_score": 1.6323128,
    "_source": {
      "title": "Solr in Action",
      "authors": [
        "trey grainger",
        "timothy potter"
      ],
      "summary": "Comprehensive guide to implementing a scalable search engine using Apache Solr",
      "publish_date": "2014-04-05",
      "num_reviews": 23,
      "publisher": "manning"
    }
  }
]

然而，使用完整的 DSL 搜索可以创建更加复杂的查询（我们等会会看到）并且你可以声明你想要的返回的结果，在下面的例子中，我们声明了我们想要返回多少个结果，偏移量是多少（这可以用来做分页），返回哪些字段以及配置高亮，注意我们使用了“match”，代替了“multi_match”，因为我们只想要搜索 title 这一个字段

POST /bookdb_index/book/_search
{
    "query": {
        "match" : {
            "title" : "in action"
        }
    },
    "size": 2,
    "from": 0,
    "_source": [ "title", "summary", "publish_date" ],
    "highlight": {
        "fields" : {
            "title" : {}
        }
    }
}
[Results]
"hits": {
  "total": 2,
  "max_score": 1.6323128,
  "hits": [
    {
      "_index": "bookdb_index",
      "_type": "book",
      "_id": "3",
      "_score": 1.6323128,
      "_source": {
        "summary": "build scalable search applications using Elasticsearch without having to do complex low-level programming or understand advanced data science algorithms",
        "title": "Elasticsearch in Action",
        "publish_date": "2015-12-03"
      },
      "highlight": {
        "title": [
          "Elasticsearch <em>in</em> <em>Action</em>"
        ]
      }
    },
    {
      "_index": "bookdb_index",
      "_type": "book",
      "_id": "4",
      "_score": 1.6323128,
      "_source": {
        "summary": "Comprehensive guide to implementing a scalable search engine using Apache Solr",
        "title": "Solr in Action",
        "publish_date": "2014-04-05"
      },
      "highlight": {
        "title": [
          "Solr <em>in</em> <em>Action</em>"
        ]
      }
    }
  ]

注意：对于多个单词的搜索，match 查询支持使用“operator”参数来声明多个单词之间的关系，可以使用 and 来代替默认的 or，你还能通过声明“minimum_should_match”参数去调整搜索结果的相关性，更多细节，查看Elasticsearch guide

提高相关度

在我们搜索多个字段的时候，我们也许想要提高某个字段的分数（相关度），在下面的例子里，我们将 summary 这个字段的分数提高到了 3，增加这个字段的重要性，反过来说，这增加了_id 为 4 的这条数据的相关性

POST /bookdb_index/book/_search
{
    "query": {
        "multi_match" : {
            "query" : "elasticsearch guide",
            "fields": ["title", "summary^3"]
        }
    },
    "_source": ["title", "summary", "publish_date"]
}
[Results]
"hits": {
  "total": 3,
  "max_score": 3.9835935,
  "hits": [
    {
      "_index": "bookdb_index",
      "_type": "book",
      "_id": "4",
      "_score": 3.9835935,
      "_source": {
        "summary": "Comprehensive guide to implementing a scalable search engine using Apache Solr",
        "title": "Solr in Action",
        "publish_date": "2014-04-05"
      }
    },
    {
      "_index": "bookdb_index",
      "_type": "book",
      "_id": "3",
      "_score": 3.1001682,
      "_source": {
        "summary": "build scalable search applications using Elasticsearch without having to do complex low-level programming or understand advanced data science algorithms",
        "title": "Elasticsearch in Action",
        "publish_date": "2015-12-03"
      }
    },
    {
      "_index": "bookdb_index",
      "_type": "book",
      "_id": "1",
      "_score": 2.0281231,
      "_source": {
        "summary": "A distibuted real-time search and analytics engine",
        "title": "Elasticsearch: The Definitive Guide",
        "publish_date": "2015-02-07"
      }
    }
  ]

备注：提升相关度并不仅仅意味着计算得分乘以提升因子。应用的实际增强值通过标准化和一些内部优化。有关原理以及更多信息 Elasticsearch guide

布尔查询

AND/OR/NOT 操作符可以用来微调我们的搜索，使得搜索结果更加的符合预期，在 search Api 中，这被称之为布尔查询，布尔查询可以使用参数 must（等同于 AND），可以使用参数must_not（等同于 NOT）和参数should（等同于 OR），举例来说，如果我想要搜索 title 为“Elasticsearch”或者“Solr”，并且 authored 为“clinton gormley”但又不等于“radu gheorge”的 books

POST /bookdb_index/book/_search
{
  "query": {
    "bool": {
      "must": {
        "bool" : { 
          "should": [
            { "match": { "title": "Elasticsearch" }},
            { "match": { "title": "Solr" }} 
          ],
          "must": { "match": { "authors": "clinton gormely" }} 
        }
      },
      "must_not": { "match": {"authors": "radu gheorge" }}
    }
  }
}
[Results]
"hits": [
  {
    "_index": "bookdb_index",
    "_type": "book",
    "_id": "1",
    "_score": 2.0749094,
    "_source": {
      "title": "Elasticsearch: The Definitive Guide",
      "authors": [
        "clinton gormley",
        "zachary tong"
      ],
      "summary": "A distibuted real-time search and analytics engine",
      "publish_date": "2015-02-07",
      "num_reviews": 20,
      "publisher": "oreilly"
    }
  }
]

备注：可以看到，一个布尔查询（bool）可以嵌套另一个布尔查询，并且可以支持无限层级嵌套

模糊查询

模糊查询可以在Match和Multi-Match查询里使用，来解决用户拼写错误，模糊查询的程度声明基于原单词的莱温斯坦距离，即：需要对一个字符串进行一个字符更改的数量，以使其与另一个字符串相同。

POST /bookdb_index/book/_search
{
    "query": {
        "multi_match" : {
            "query" : "comprihensiv guide",
            "fields": ["title", "summary"],
            "fuzziness": "AUTO"
        }
    },
    "_source": ["title", "summary", "publish_date"],
    "size": 1
}
[Results]
"hits": [
  {
    "_index": "bookdb_index",
    "_type": "book",
    "_id": "4",
    "_score": 2.4344182,
    "_source": {
      "summary": "Comprehensive guide to implementing a scalable search engine using Apache Solr",
      "title": "Solr in Action",
      "publish_date": "2014-04-05"
    }
  }
]

备注：除了“AUTO”，还可以指定数字 0，1 或者 2 去声明，可以匹配到一个单词的最大字符数，使用“AUTO”的好处是它考虑了字符串的长度，对于一个只有三个字符的单词，指定模糊匹配的字符数量为 2，显然对于性能是有问题的，因此，大部分情况还是建议使用“AUTO”

通配符查询

通配符查询允许你使用一个通配符来代替完整匹配。?可匹配任意字符，*可以匹配 0 或者更多其他字符，比如，我们要查找一条 authors 是"t"开头的数据

POST /bookdb_index/book/_search
{
    "query": {
        "wildcard" : {
            "authors" : "t*"
        }
    },
    "_source": ["title", "authors"],
    "highlight": {
        "fields" : {
            "authors" : {}
        }
    }
}
[Results]
"hits": [
  {
    "_index": "bookdb_index",
    "_type": "book",
    "_id": "1",
    "_score": 1,
    "_source": {
      "title": "Elasticsearch: The Definitive Guide",
      "authors": [
        "clinton gormley",
        "zachary tong"
      ]
    },
    "highlight": {
      "authors": [
        "zachary <em>tong</em>"
      ]
    }
  },
  {
    "_index": "bookdb_index",
    "_type": "book",
    "_id": "2",
    "_score": 1,
    "_source": {
      "title": "Taming Text: How to Find, Organize, and Manipulate It",
      "authors": [
        "grant ingersoll",
        "thomas morton",
        "drew farris"
      ]
    },
    "highlight": {
      "authors": [
        "<em>thomas</em> morton"
      ]
    }
  },
  {
    "_index": "bookdb_index",
    "_type": "book",
    "_id": "4",
    "_score": 1,
    "_source": {
      "title": "Solr in Action",
      "authors": [
        "trey grainger",
        "timothy potter"
      ]
    },
    "highlight": {
      "authors": [
        "<em>trey</em> grainger",
        "<em>timothy</em> potter"
      ]
    }
  }
]

正则表达式查询

正则表达式查询允许你声明比通配查询更加复杂的查询

POST /bookdb_index/book/_search
{
    "query": {
        "regexp" : {
            "authors" : "t[a-z]*y"
        }
    },
    "_source": ["title", "authors"],
    "highlight": {
        "fields" : {
            "authors" : {}
        }
    }
}
[Results]
"hits": [
  {
    "_index": "bookdb_index",
    "_type": "book",
    "_id": "4",
    "_score": 1,
    "_source": {
      "title": "Solr in Action",
      "authors": [
        "trey grainger",
        "timothy potter"
      ]
    },
    "highlight": {
      "authors": [
        "<em>trey</em> grainger",
        "<em>timothy</em> potter"
      ]
    }
  }
]

短句查询

短句查询需要匹配所有单词才能被搜索出来，按照指定的顺序并且是连续的，默认情况下单词之间必须是连续的，但是你可以通过改写“slop”的值来声明即便两个单词之间间隔多少个单词，该文档仍然能被匹配出来

POST /bookdb_index/book/_search
{
    "query": {
        "match_phrase_prefix" : {
            "summary": {
                "query": "search en",
                "slop": 3,
                "max_expansions": 10
            }
        }
    },
    "_source": [ "title", "summary", "publish_date" ]
}
[Results]
"hits": [
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "4",
        "_score": 0.5161346,
        "_source": {
          "summary": "Comprehensive guide to implementing a scalable search engine using Apache Solr",
          "title": "Solr in Action",
          "publish_date": "2014-04-05"
        }
      },
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "1",
        "_score": 0.37248808,
        "_source": {
          "summary": "A distibuted real-time search and analytics engine",
          "title": "Elasticsearch: The Definitive Guide",
          "publish_date": "2015-02-07"
        }
      }
    ]

备注：Query-time search-as-you-type 有一定的性能成本，更好的方案是 index-time search-as-you-type，查看Completion Suggester API或者使用 Edge-Ngram查看更多信息

Query String

query_string查询提供了一种将“multi_match 查询”，“布尔查询”，“boosting”，“模糊查询”，“通配查询”，“范围查询”整合在一个短句里的方法，下面的查询，匹配“grant ingersoll”或者“tom morton.”且含有短句“grant ingersoll”，然后还将 summary 字段的分数提到了 2

POST /bookdb_index/book/_search
{
    "query": {
        "query_string" : {
            "query": "(saerch~1 algorithm~1) AND (grant ingersoll)  OR (tom morton)",
            "fields": ["title", "authors" , "summary^2"]
        }
    },
    "_source": [ "title", "summary", "authors" ],
    "highlight": {
        "fields" : {
            "summary" : {}
        }
    }
}
[Results]
"hits": [
  {
    "_index": "bookdb_index",
    "_type": "book",
    "_id": "2",
    "_score": 3.571021,
    "_source": {
      "summary": "organize text using approaches such as full-text search, proper name recognition, clustering, tagging, information extraction, and summarization",
      "title": "Taming Text: How to Find, Organize, and Manipulate It",
      "authors": [
        "grant ingersoll",
        "thomas morton",
        "drew farris"
      ]
    },
    "highlight": {
      "summary": [
        "organize text using approaches such as full-text <em>search</em>, proper name recognition, clustering, tagging"
      ]
    }
  }
]

简化的 Query String

simple_query_string是query_string的一个版本，更加适合用在一个单独的搜索框里暴露给用户使用，因为它将 AND/OR/NOT 分别变成了 +/|/-，并且这种查询将不会直接将查询的语法错误直接抛出

POST /bookdb_index/book/_search
{
    "query": {
        "simple_query_string" : {
            "query": "(saerch~1 algorithm~1) + (grant ingersoll)  | (tom morton)",
            "fields": ["title", "authors" , "summary^2"]
        }
    },
    "_source": [ "title", "summary", "authors" ],
    "highlight": {
        "fields" : {
            "summary" : {}
        }
    }
}

Term/Terms 查询

以上的例子展示了full-text搜索，有时候我们也会想要一个精确的匹配，term以及terms查询可以帮助我们做到这一点，下面的例子中，我们搜索了所有发布者为“Manning”发布的 books

POST /bookdb_index/book/_search
{
    "query": {
        "term" : {
            "publisher": "manning"
        }
    },
    "_source" : ["title","publish_date","publisher"]
}
[Results]
"hits": [
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "2",
        "_score": 1.2231436,
        "_source": {
          "publisher": "manning",
          "title": "Taming Text: How to Find, Organize, and Manipulate It",
          "publish_date": "2013-01-24"
        }
      },
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "3",
        "_score": 1.2231436,
        "_source": {
          "publisher": "manning",
          "title": "Elasticsearch in Action",
          "publish_date": "2015-12-03"
        }
      },
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "4",
        "_score": 1.2231436,
        "_source": {
          "publisher": "manning",
          "title": "Solr in Action",
          "publish_date": "2014-04-05"
        }
      }
    ]

多个terms可以用关键字terms来代替，并且可以传入一个数组

{
    "query": {
        "terms" : {
            "publisher": ["oreilly", "packt"]
        }
    }
}

Term 查询 - 排序

Term 查询的结果（也包括其他种类的查询）可以很轻松的进行排序，多级排序也是被允许的

POST /bookdb_index/book/_search
{
    "query": {
        "term" : {
            "publisher": "manning"
        }
    },
    "_source" : ["title","publish_date","publisher"],
    "sort": [
        { "publish_date": {"order":"desc"}}
    ]
}
[Results]
"hits": [
  {
    "_index": "bookdb_index",
    "_type": "book",
    "_id": "3",
    "_score": null,
    "_source": {
      "publisher": "manning",
      "title": "Elasticsearch in Action",
      "publish_date": "2015-12-03"
    },
    "sort": [
      1449100800000
    ]
  },
  {
    "_index": "bookdb_index",
    "_type": "book",
    "_id": "4",
    "_score": null,
    "_source": {
      "publisher": "manning",
      "title": "Solr in Action",
      "publish_date": "2014-04-05"
    },
    "sort": [
      1396656000000
    ]
  },
  {
    "_index": "bookdb_index",
    "_type": "book",
    "_id": "2",
    "_score": null,
    "_source": {
      "publisher": "manning",
      "title": "Taming Text: How to Find, Organize, and Manipulate It",
      "publish_date": "2013-01-24"
    },
    "sort": [
      1358985600000
    ]
  }
]

备注：在 6 之后的版本，使用 text 类型的字段排序或者分组，比如 title，你需要为那个字段指定fielddata，更多细节查看ElasticSearch Guide.

范围查询

还有另一种查询的结构我们称之为范围查询，在下面的例子里，我们搜索了所有在 2015 年发布的 books

POST /bookdb_index/book/_search
{
    "query": {
        "range" : {
            "publish_date": {
                "gte": "2015-01-01",
                "lte": "2015-12-31"
            }
        }
    },
    "_source" : ["title","publish_date","publisher"]
}
[Results]
"hits": [
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "1",
        "_score": 1,
        "_source": {
          "publisher": "oreilly",
          "title": "Elasticsearch: The Definitive Guide",
          "publish_date": "2015-02-07"
        }
      },
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "3",
        "_score": 1,
        "_source": {
          "publisher": "manning",
          "title": "Elasticsearch in Action",
          "publish_date": "2015-12-03"
        }
      }
    ]

备注：范围查询支持的字段类型有：日期，数字和字符串

筛选布尔查询

当我们使用布尔查询的时候，可以使用filter参数去筛掉一些结果，下面的例子中，我们查询了 title 或者 summary 字段含有“Elasticsearch”,与此同时我们还需要 reviews 的数量大于等于 20

POST /bookdb_index/book/_search
{
    "query": {
        "filtered": {
            "query" : {
                "multi_match": {
                    "query": "elasticsearch",
                    "fields": ["title","summary"]
                }
            },
            "filter": {
                "range" : {
                    "num_reviews": {
                        "gte": 20
                    }
                }
            }
        }
    },
    "_source" : ["title","summary","publisher", "num_reviews"]
}
[Results]
"hits": [
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "1",
        "_score": 0.5955761,
        "_source": {
          "summary": "A distibuted real-time search and analytics engine",
          "publisher": "oreilly",
          "num_reviews": 20,
          "title": "Elasticsearch: The Definitive Guide"
        }
      }
    ]

多个 filters 可以再一个bool查询中结合起来使用，下一个例子中，filter 规定了结果必须含有最少 20 个 reviews，发布时间不能早于 2015 年，并且发布人应该是 Reilly

POST /bookdb_index/book/_search
{
    "query": {
        "filtered": {
            "query" : {
                "multi_match": {
                    "query": "elasticsearch",
                    "fields": ["title","summary"]
                }
            },
            "filter": {
                "bool": {
                    "must": {
                        "range" : { "num_reviews": { "gte": 20 } }
                    },
                    "must_not": {
                        "range" : { "publish_date": { "lte": "2014-12-31" } }
                    },
                    "should": {
                        "term": { "publisher": "oreilly" }
                    }
                }
            }
        }
    },
    "_source" : ["title","summary","publisher", "num_reviews", "publish_date"]
}
[Results]
"hits": [
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "1",
        "_score": 0.5955761,
        "_source": {
          "summary": "A distibuted real-time search and analytics engine",
          "publisher": "oreilly",
          "num_reviews": 20,
          "title": "Elasticsearch: The Definitive Guide",
          "publish_date": "2015-02-07"
        }
      }
    ]

自己写的 Gem, VueRails，让 Vue 在 Rails 里服务端渲染！并支持 vue-router 和 vuex

ad583255925 — Fri, 01 Mar 2019 14:20:00 +0800

webpacker 已经普及在各个 rails 项目里很久了，在 rails 项目里使用 Vue 组件来强化用户体验，甚至整个项目都用一个完整的VueApp来做都是很正常的。关于他的老对头 React 有一个 Gem，ReactRails，我翻了一下有没有关于 Vue 的类似 Gem，结果都不是很完善，于是自己动手写了一个，也借鉴了里面很多思路和代码，希望大家支持，如果在使用过程中碰到什么 bug，可以到项目地址提交问题。

https://github.com/jiyarong/vue_rails

废话不多说，先上 Demo，体验一下服务端渲染优化后的首屏加载！

Demo 地址右上角登录 admin(密码也是 admin) 可以体验完整的 CURD

这是一台带宽只有 1m 的机器，正常情况下，一个 bundle 要下载好几秒，如果不用服务端渲染，情况就很糟糕，但是现在你应该几乎看不到白屏时间，即便 js 还在下载

解决了哪些问题

1. 合理初始化 Vue 组件

之前比较普遍的做法是，在 html 里放一个 div 作为根组件，在 js 里监控 dom 事件，有 Turbolinks 的可能还要额外处理一些事件，总之就是在某个事件触发后，初始化一个Vue组件，这种做法初始化一个 Vue 组件一般的步骤是：

写一个组件 -> 在某个页面放一个 Div -> 在 application.js 引入这个组件 -> 监听 dom 事件，如果找到这个 div -> 初始化组件。

这样做先不说步骤比较多，最大的问题在于，在一个页面有多个 Vue 组件后，你很难在一堆 html 里一眼看出这是不是一个 Vue 组件，装了这个 Gem 后，步骤变为

写一个组件 -> 直接在 html 里引用

<%= vue_component('hello') %>

这样看起来是不是好多了！并且也不怕在一个页面内初始化多个 Vue 组件了，你不必考虑 Turbolinks 的兼容问题，我已经全部做掉了

2. 服务端渲染

打包后的 js 往往会很大，用户第一次访问你的网站的时候，如果机器的带宽不够，会出现白屏时间过长的问题，这对于用户的体验来说不是很友好，然而如果能让用户先看到一个画面，再继续下载 js，对于用户体验来说会好很多，同时解决了SEO的问题，但是配置服务端渲染往往非常繁琐，尤其我们的服务端还不是 nodejs，在这方面就更困难了，我在这个 GEM 里把这些事都做了，你只需要一个参数，就能打开服务端渲染，详情可以看下面的文档，原理是基于execjs + vue-server-renderer + webpacker，同是我兼容了vue-router和vuex

接下来是文档部分，文档还在持续完善中，希望大家支持

项目地址 https://github.com/jiyarong/vue_rails

VueRails

基于 Webpacker

将 webpacker 和 vue_rails 加入 gemfile

gem 'webpacker'
gem 'vue_rails'

跑一些 installer

$ bundle install
$ rails webpacker:install
$ rails webpacker:install:vue
$ rails generate vue:install

确认文件夹结构

|-- app
   |-- javascript
      |-- packs
         |-- application.js
         |-- vue_server_render.js
      |-- vue_components
         |-- hello.vue
      |-- rails_vue_ujs.js

所有的 Vue 组件现在都应该放在 `vue_components`里面

基本用法

1. 添加 javascript_pack_tag 到 application.html

<%= javascript_pack_tag 'application', 'data-turbolinks-track': 'reload' %>

2. 建一个控制器和页面

example:

$ rails generate controller home index

别忘了路由设置

3. 打开 home/index.html，加入如下代码

<%= vue_component("hello") %>

一个页面里数个组件也是没问题，即便他们是相同的组件

<%= vue_component("hello") %>
<%= vue_component("hello") %>
<%= vue_component("hello") %>

4. 打开浏览器，现在应该已经成功了！

Vue 文件路径和组件名之间的关系

/vue_components/hello.vue -> vue_component('hello')

/vue_components/post/index.vue -> vue_component('post/index')

/vue_components/post/edit/index.vue -> vue_component('post/edit/index')

高级用法

给组件传参

<%= vue_component("hello", {foo: 'bar'}) %>

in your component hello.vue:

<template>
  <div id="app">
    <p>{{ outside.foo }}</p>
  </div>
</template>

<script>
  export default {
    props: ['outside'],
    data: function () {
      return {
        message: "Hello Vue!"
      }
    }
  }
</script>

数组或者 hash 都没问题

<%= vue_component("hello", {foo: {name: 'Peter'}}) %>

<template>
  <div id="app">
    <p>{{ outside.foo.name }}</p>
  </div>
</template>

<script>
  export default {
    props: ['outside'],
    data: function () {
      return {
        message: "Hello Vue!"
      }
    }
  }
</script>

<%= vue_component("hello", {foo: [1,2,3]}) %>

<template>
  <div id="app">
    <template v-for="i in outside.foo">
      <div>{{i}}</div>
    </template> 
    <p>{{ outside.foo.name }}</p>
  </div>
</template>

<script>
  export default {
    props: ['outside'],
    data: function () {
      return {
        message: "Hello Vue!"
      }
    }
  }
</script>

outside 里面自带 csrf_token，你做表单类的组件一定会用得到的 (outside.csrf_token)

服务端渲染

如果不是打算整个项目都用 VueApp 来做，不要使用服务端渲染！

使用参数 prerender, 将会自动打开服务端渲染

<%= vue_component("hello", {foo: [1,2,3]}, {prerender: true}) %>

除了 outside, 还有一个 props 用来区别环境是否是服务端渲染，env_ssr，true 为服务端，false 则为客户端

有一些组件会在服务端渲染时出错，使用该值来区分一下

<some-component v-if="!env_ssr" />

调整 js 标签的位置

<!DOCTYPE html>
<html>
  <head>
    <title>RailsVueSsr</title>
    <%= csrf_meta_tags %>
    <%= csp_meta_tag %>
    <%= stylesheet_pack_tag 'application' %>
  </head>

  <body>
    <%= yield %>
  </body>
  <%= javascript_pack_tag 'application', 'data-turbolinks-track': 'reload' %>

</html>

javascript_pack_tag 必须在 body 下面，不然会卡主主线程从而使服务端渲染无效

和 vue-router 一起使用

$ yarn add vue-router

在 application.js 和 vue_server_render.js 里添加如下代码

import VueRouter from 'vue-router';

RailsVueUJS.use(VueRouter);

在 vue 组件里

<template>
    <div class="container">
      <div class="content">
        <router-view :outside="outside" :env_ssr="env_ssr"></router-view>
      </div>
    </div>
</template>

<script>
  import VueRouter from 'vue-router';
  import PostList from './posts/index';
  import PostDetail from './posts/show';
  import newPost from './posts/new';
  import EditPost from './posts/edit';

  const routes = [
    {
      path: '/',
      component: PostList,
      name: 'post_index',
      props: true
    },
    {
      path: '/posts/new',
      component: newPost,
      name: 'new_post'
    },
    {
      path: '/posts/edit/:id',
      component: EditPost,
      name: 'edit_post'
    },
    {
      path: '/posts/:id',
      component: PostDetail,
      name: 'post_detail'
    }
  ];

  const router = new VueRouter({
    mode: 'history',
    routes
  });

  export default {
    props: ['outside', 'env_ssr'],
    router
  };
</script>

参数 prerender 还可以接受一个路由传给 vue-router

<%= vue_component("hello", {foo: [1,2,3]}, {prerender: request.path}) %>

in your routes.rb

get '*path', to: 'home#index'

和 vuex 一起使用

$ yarn add vuex

初始化一个 store

import Vue from 'vue'
import Vuex from 'vuex';

Vue.use(Vuex);
const store = new Vuex.Store({
  state: {
    currentUser: {},
    hasLogin: false
  }
});

export default store;

在 application.js 和 vue_server_render.js 里添加如下代码

import VueRouter from 'vue-router';
import Vuex from 'vuex';
import store from "../vue_components/store";

RailsVueUJS.use(VueRouter, Vuex);
RailsVueUJS.initializeVuexStore(store);
...

in your html file

<%= vue_component("hello", {foo: [1,2,3]}, {prerender: true, state: {
  hasLogin: true
}}) %>

使用参数 state,这会覆盖你的初始 store, 服务端渲染和客户端渲染同样都会生效

组件内

...
<div v-if="$store.state.hasLogin">
  <a href="/users/logout">logout</a>
</div>
...

n = 3233, e = 17, 明文是 65，密文根据公式得出 2790，但是如果明文是字符串，密文怎么算

ad583255925 — Thu, 20 Sep 2018 15:42:37 +0800

对接的客户公司，给的公钥分为了 n 和 e

c = (65**17). modulo(3233) = 2790

c 就是密文

但是假设说我要加密的是字符串，我是把字符串转化为什么，用什么方法

想在微信 H5 应用里加入 service worker，结果发现不少问题

ad583255925 — Fri, 14 Sep 2018 10:58:32 +0800

目前卡在 service worker 内代理的请求，user-agent 是没有带微信标识的，然后在 service worker 里面其实不提倡更改请求头，改起来也很麻烦，有没有人也尝试过 service worker 在微信端浏览器里的表现

服务器如何强行指定一次请求头的 Content-Type 为 application/json

ad583255925 — Tue, 04 Sep 2018 17:13:45 +0800

我们是一个 api 服务器，客户请求我们的时候，Content-Type 是 text/plain，请求体却是 json 格式的，让他们改，他们意思是改起来很困难，所以我们现在得自己想办法改了，结果发现这还真不是那么好改的 (加个 Rack 中间件？)，至少会很别扭，你们怎么看

所有用 Rails 写的网站，在参数后面加上?foo=%9g，都会直接返回一个 400，而且好像抓不住这个报错

ad583255925 — Wed, 29 Aug 2018 16:49:03 +0800

我们的网站里会经常会出现一些参数编码不正确的请求，想抓住这个报错，然后比较友善的返回给请求方控制器里加了

rescue_from Rack::QueryParser::InvalidParameterError do |ex|
    render_error("无效参数: #{ex.message}", 400)
end

在开发过程中，我造了一个这样不合法的请求

http://localhost:3000/enjar/coupons/12312312?foo=%9g

然而虽然确实返回了 400，但是我的日志并没有动，而且也没有文字 (无效参数：xxxx) 返回来，但是我关掉服务，确实变成了 404，求问一下，这个报错怎么抓

负载均衡的两台服务器里的项目，如何实现 public 下的资源共享

ad583255925 — Tue, 28 Aug 2018 17:49:55 +0800

访问 A 服务器的一张图片，404 之后再去 B 尝试一下，这种方案是否可行

把一个巨大的 hash 放在一个类的常量里面，和作为方法放在类里面，哪个比较好

ad583255925 — Tue, 31 Jul 2018 17:22:51 +0800

有一个类，专门用来提供配置的，里面有一大堆的配置，为了图方便就直接放在常量里了

class MyClass
  CONFIG = {
    config1: {
      ...
    },
    config2: {
      ...
    },
   ...
  }
end

class MyClass
  def self.config1
      {
        ...
      }
  end

  def self.config2
    {
      ...
    }
  end
  ...
end

哪种会比较好一点

ElixirChina 发生了什么，凉了吗？

ad583255925 — Tue, 03 Jul 2018 19:05:19 +0800

http://elixir-cn.com/?page=1

求推荐一个好用的生产环境管理错误日志的平台，付费的也可以

ad583255925 — Mon, 25 Jun 2018 10:38:02 +0800

求推荐一个好用的生产环境错误捕捉 + 管理错误日志的平台，付费的也可以现在用的免费的 sentry，redis 经常爆

对于想要使用`webpacker`的 5.2 的 Rails 新项目，仅仅把 packs 作为一种渲染工具，还是把项目逻辑全写在 packs 里变成一个单页应用比较好，利弊各有哪些？

ad583255925 — Mon, 04 Jun 2018 17:41:29 +0800

我想试试这个https://github.com/reactjs/react-rails

但是现在不知道该把逻辑写在 rails 里还是 packs 里

Mac os High Sierra 10.13.4 U 盘插上去毫无反应

ad583255925 — Mon, 21 May 2018 10:28:09 +0800

你们碰到过吗

Docker 跑一个 rails 项目，缺少 nodejs runtime，一般怎么弄

ad583255925 — Fri, 23 Mar 2018 14:55:09 +0800

我现在是想这样项目下的 Dockerfile

FROM ruby:2.3

WORKDIR /app

COPY Gemfile Gemfile.lock ./

COPY . .

RUN bundle install

项目下的 docker-compose.yml

version: '3'
services:
  web:
    build: .
    command: rails s
    ports:
      - "3000:3000"
    volumes:
      - .:/app
    links:
      - node
  node:
    image: node

但是这样好像不起作用

使用 Mina 1.0 碰到了点奇怪的问题，求助

ad583255925 — Mon, 19 Mar 2018 12:30:52 +0800

我新建了一个项目，然后安装了 mina，版本是 1.2.3 的，在 deploy.rb 里面设置了如下参数

set :application_name, 'rails_deploy'
set :domain, 'ubuntu@u1c2g'
set :deploy_to, '/var/www/rails_deploy'
set :repository, 'https://github.com/jiyarong/rails-deploy.git'
set :branch, 'master'

ruby_version = "2.3.1"

task :remote_environment do
  invoke :"rvm:use", ruby_version
end

其他的都没改，都是默认设置，这样子mina setup mina deploy是没问题的但是我想在 shared_path 里面再继续加入config里面的若干文件

set :shared_dirs, fetch(:shared_dirs, []).push('config')
set :shared_files, fetch(:shared_files, []).push('config/database.yml', 'config/secrets.yml', 'config/application.rb')

这样子跑deploy就会报错

Creating database
       rake aborted!
       LoadError: cannot load such file -- /var/www/rails_deploy/tmp/build-152143332714966/config/application
       /var/www/rails_deploy/tmp/build-152143332714966/Rakefile:4:in `require_relative'
       /var/www/rails_deploy/tmp/build-152143332714966/Rakefile:4:in `<top (required)>'
       /var/www/rails_deploy/tmp/build-152143332714966/vendor/bundle/ruby/2.3.0/gems/rake-12.3.0/exe/rake:27:in `<top (required)>'
       /home/ubuntu/.rvm/gems/ruby-2.3.1/gems/bundler-1.16.1/lib/bundler/cli/exec.rb:75:in `load'
       /home/ubuntu/.rvm/gems/ruby-2.3.1/gems/bundler-1.16.1/lib/bundler/cli/exec.rb:75:in `kernel_load'
       /home/ubuntu/.rvm/gems/ruby-2.3.1/gems/bundler-1.16.1/lib/bundler/cli/exec.rb:28:in `run'
       /home/ubuntu/.rvm/gems/ruby-2.3.1/gems/bundler-1.16.1/lib/bundler/cli.rb:424:in `exec'
       /home/ubuntu/.rvm/gems/ruby-2.3.1/gems/bundler-1.16.1/lib/bundler/vendor/thor/lib/thor/command.rb:27:in `run'
       /home/ubuntu/.rvm/gems/ruby-2.3.1/gems/bundler-1.16.1/lib/bundler/vendor/thor/lib/thor/invocation.rb:126:in `invoke_command'
       /home/ubuntu/.rvm/gems/ruby-2.3.1/gems/bundler-1.16.1/lib/bundler/vendor/thor/lib/thor.rb:387:in `dispatch'
       /home/ubuntu/.rvm/gems/ruby-2.3.1/gems/bundler-1.16.1/lib/bundler/cli.rb:27:in `dispatch'
       /home/ubuntu/.rvm/gems/ruby-2.3.1/gems/bundler-1.16.1/lib/bundler/vendor/thor/lib/thor/base.rb:466:in `start'
       /home/ubuntu/.rvm/gems/ruby-2.3.1/gems/bundler-1.16.1/lib/bundler/cli.rb:18:in `start'
       Connection to u1c2g closed.