分类目录归档:Ruby

ruby-rails的自启动脚本

必须设置HOME的环境变量,否则会报错【后续有测试发现不设置HOME变量时,也是可以正常运行的,但为了安全起见,还是设置吧】。
如下:

RVM is not a function, selecting rubies with 'rvm use ...' will not work.

正确的写法如下:

*/3 * * * * HOME=/home/waypal && source $HOME/.bash_profile && rvm use 'ruby 2.4.1@default'  --create && eval `rvm env` && $HOME/waypalers.cn/waypal/current/run-waypal.sh start

nginx+unicorn部署方案

三种运行方式
不配置unicorn.rb的方式
unicorn_rails -D -l 0.0.0.0:3000 -E development
配置unicorn.rb的方式
unicorn_rails -c /path/to/app/config/unicorn.rb -D -E production
无缝重启方式,如nginx -s reload
kill -USR2 `cat path/to/app/tmp/pids/unicorn.pid`
————————————–
1.在Gemfile中加入

在Gemfile中加入以下一行。
gem 'unicorn'
在命令行中执行以下一行
bundle install

2.listen方式

listen 3000 # listen to port 3000 on all TCP interfaces
listen "127.0.0.1:3000"  # listen to port 3000 on the loopback interface
listen "/tmp/.unicorn.sock" # listen on the given Unix domain socket
listen "[::1]:3000" # listen to port 3000 on the IPv6 loopback interface

3.官方最小配置

listen 2007 # by default Unicorn listens on port 8080
worker_processes 2 # this should be >= nr_cpus
pid "/path/to/app/shared/pids/unicorn.pid"
stderr_path "/path/to/app/shared/log/unicorn.log"
stdout_path "/path/to/app/shared/log/unicorn.log"

4.官方最完整配置

# Sample verbose configuration file for Unicorn (not Rack)
#
# This configuration file documents many features of Unicorn
# that may not be needed for some applications. See
# https://bogomips.org/unicorn/examples/unicorn.conf.minimal.rb
# for a much simpler configuration file.
#
# See https://bogomips.org/unicorn/Unicorn/Configurator.html for complete
# documentation.
 
# Use at least one worker per core if you're on a dedicated server,
# more will usually help for _short_ waits on databases/caches.
worker_processes 4
 
# Since Unicorn is never exposed to outside clients, it does not need to
# run on the standard HTTP port (80), there is no reason to start Unicorn
# as root unless it's from system init scripts.
# If running the master process as root and the workers as an unprivileged
# user, do this to switch euid/egid in the workers (also chowns logs):
# user "unprivileged_user", "unprivileged_group"
 
# Help ensure your application will always spawn in the symlinked
# "current" directory that Capistrano sets up.
working_directory "/path/to/app/current" # available in 0.94.0+
 
# listen on both a Unix domain socket and a TCP port,
# we use a shorter backlog for quicker failover when busy
listen "/path/to/.unicorn.sock", :backlog => 64
listen 8080, :tcp_nopush => true
 
# nuke workers after 30 seconds instead of 60 seconds (the default)
timeout 30
 
# feel free to point this anywhere accessible on the filesystem
pid "/path/to/app/shared/pids/unicorn.pid"
 
# By default, the Unicorn logger will write to stderr.
# Additionally, ome applications/frameworks log to stderr or stdout,
# so prevent them from going to /dev/null when daemonized here:
stderr_path "/path/to/app/shared/log/unicorn.stderr.log"
stdout_path "/path/to/app/shared/log/unicorn.stdout.log"
 
# combine Ruby 2.0.0+ with "preload_app true" for memory savings
preload_app true
 
# Enable this flag to have unicorn test client connections by writing the
# beginning of the HTTP headers before calling the application.  This
# prevents calling the application for connections that have disconnected
# while queued.  This is only guaranteed to detect clients on the same
# host unicorn runs on, and unlikely to detect disconnects even on a
# fast LAN.
check_client_connection false
 
# local variable to guard against running a hook multiple times
run_once = true
 
before_fork do |server, worker|
  # the following is highly recomended for Rails + "preload_app true"
  # as there's no need for the master process to hold a connection
  defined?(ActiveRecord::Base) and
    ActiveRecord::Base.connection.disconnect!
 
  # Occasionally, it may be necessary to run non-idempotent code in the
  # master before forking.  Keep in mind the above disconnect! example
  # is idempotent and does not need a guard.
  if run_once
    # do_something_once_here ...
    run_once = false # prevent from firing again
  end
 
  # The following is only recommended for memory/DB-constrained
  # installations.  It is not needed if your system can house
  # twice as many worker_processes as you have configured.
  #
  # # This allows a new master process to incrementally
  # # phase out the old master process with SIGTTOU to avoid a
  # # thundering herd (especially in the "preload_app false" case)
  # # when doing a transparent upgrade.  The last worker spawned
  # # will then kill off the old master process with a SIGQUIT.
  # old_pid = "#{server.config[:pid]}.oldbin"
  # if old_pid != server.pid
  #   begin
  #     sig = (worker.nr + 1) >= server.worker_processes ? :QUIT : :TTOU
  #     Process.kill(sig, File.read(old_pid).to_i)
  #   rescue Errno::ENOENT, Errno::ESRCH
  #   end
  # end
  #
  # Throttle the master from forking too quickly by sleeping.  Due
  # to the implementation of standard Unix signal handlers, this
  # helps (but does not completely) prevent identical, repeated signals
  # from being lost when the receiving process is busy.
  # sleep 1
end
 
after_fork do |server, worker|
  # per-process listener ports for debugging/admin/migrations
  # addr = "127.0.0.1:#{9293 + worker.nr}"
  # server.listen(addr, :tries => -1, :delay => 5, :tcp_nopush => true)
 
  # the following is *required* for Rails + "preload_app true",
  defined?(ActiveRecord::Base) and
    ActiveRecord::Base.establish_connection
 
  # if preload_app is true, then you may also want to check and
  # restart any other shared sockets/descriptors such as Memcached,
  # and Redis.  TokyoCabinet file handles are safe to reuse
  # between any number of forked children (assuming your kernel
  # correctly implements pread()/pwrite() system calls)
end

5.GitHub配置

# unicorn_rails -c /data/github/current/config/unicorn.rb -E production -D
 
rails_env = ENV['RAILS_ENV'] || 'production'
 
# 16 workers and 1 master
worker_processes (rails_env == 'production' ? 16 : 4)
 
# Load rails+github.git into the master before forking workers
# for super-fast worker spawn times
preload_app true
 
# Restart any workers that haven't responded in 30 seconds
timeout 30
 
# Listen on a Unix data socket
listen '/data/github/current/tmp/sockets/unicorn.sock', :backlog => 2048
 
 
##
# REE
 
# http://www.rubyenterpriseedition.com/faq.html#adapt_apps_for_cow
if GC.respond_to?(:copy_on_write_friendly=)
  GC.copy_on_write_friendly = true
end
 
 
before_fork do |server, worker|
  ##
  # When sent a USR2, Unicorn will suffix its pidfile with .oldbin and
  # immediately start loading up a new version of itself (loaded with a new
  # version of our app). When this new Unicorn is completely loaded
  # it will begin spawning workers. The first worker spawned will check to
  # see if an .oldbin pidfile exists. If so, this means we've just booted up
  # a new Unicorn and need to tell the old one that it can now die. To do so
  # we send it a QUIT.
  #
  # Using this method we get 0 downtime deploys.
 
  old_pid = RAILS_ROOT + '/tmp/pids/unicorn.pid.oldbin'
  if File.exists?(old_pid) && server.pid != old_pid
    begin
      Process.kill("QUIT", File.read(old_pid).to_i)
    rescue Errno::ENOENT, Errno::ESRCH
      # someone else did our job for us
    end
  end
end
 
 
after_fork do |server, worker|
  ##
  # Unicorn master loads the app then forks off workers - because of the way
  # Unix forking works, we need to make sure we aren't using any of the parent's
  # sockets, e.g. db connection
 
  ActiveRecord::Base.establish_connection
  CHIMNEY.client.connect_to_server
  # Redis and Memcached would go here but their connections are established
  # on demand, so the master never opens a socket
 
 
  ##
  # Unicorn master is started as root, which is fine, but let's
  # drop the workers to git:git
 
  begin
    uid, gid = Process.euid, Process.egid
    user, group = 'git', 'git'
    target_uid = Etc.getpwnam(user).uid
    target_gid = Etc.getgrnam(group).gid
    worker.tmp.chown(target_uid, target_gid)
    if uid != target_uid || gid != target_gid
      Process.initgroups(user, target_gid)
      Process::GID.change_privilege(target_gid)
      Process::UID.change_privilege(target_uid)
    end
  rescue => e
    if RAILS_ENV == 'development'
      STDERR.puts "couldn't change user, oh well"
    else
      raise e
    end
  end
end

6.自定义配置一

module Rails
  class <<self
    def root
      File.expand_path(__FILE__).split('/')[0..-3].join('/')
    end
  end
end
 
worker_processes 4
 
working_directory Rails.root
 
listen "#{Rails.root}/tmp/sockets/socket", :backlog => 64
 
timeout 30
 
pid "#{Rails.root}/tmp/pids/unicorn.pid"
 
stderr_path "#{Rails.root}/log/unicorn.log"
stdout_path "#{Rails.root}/log/unicorn.log"
 
# combine Ruby 2.0.0dev or REE with "preload_app true" for memory savings
# http://rubyenterpriseedition.com/faq.html#adapt_apps_for_cow
preload_app true
GC.respond_to?(:copy_on_write_friendly=) and
  GC.copy_on_write_friendly = true
 
check_client_connection false
 
before_fork do |server, worker|
  # the following is highly recomended for Rails + "preload_app true"
  # as there's no need for the master process to hold a connection
  defined?(ActiveRecord::Base) and
    ActiveRecord::Base.connection.disconnect!
 
  old_pid = "#{server.config[:pid]}.oldbin"
  if File.exists?(old_pid) && old_pid != server.pid
    begin
      sig = (worker.nr + 1) >= server.worker_processes ? :QUIT : :TTOU
      Process.kill(sig, File.read(old_pid).to_i)
    rescue Errno::ENOENT, Errno::ESRCH
    end
  end
 
  # Throttle the master from forking too quickly by sleeping.  Due
  # to the implementation of standard Unix signal handlers, this
  # helps (but does not completely) prevent identical, repeated signals
  # from being lost when the receiving process is busy.
  sleep 1
end
 
after_fork do |server, worker|
 
  # the following is *required* for Rails + "preload_app true",
  defined?(ActiveRecord::Base) and
    ActiveRecord::Base.establish_connection
 
  # if preload_app is true, then you may also want to check and
  # restart any other shared sockets/descriptors such as Memcached,
  # and Redis.  TokyoCabinet file handles are safe to reuse
  # between any number of forked children (assuming your kernel
  # correctly implements pread()/pwrite() system calls)
end

7.自定义配置二

# -*- encoding: utf-8 -*-
user("menxu","menxu")
 
 
root_path = File.expand_path '../', File.dirname(__FILE__)
#log
log_file = root_path + '/log/unicorn.log'
err_log  = root_path + '/log/unicorn_error.log'
 
 
# process
pid_file = '/tmp/unicorn_padrino.pid'
old_pid = pid_file + '.oldbin'
 
 
#thron
socket_file = '/tmp/unicorn_padrino.sock'
 
 
worker_processes 2
working_directory root_path
timeout 30
 
 
#listen
listen 8080, tcp_nopush: false
listen socket_file, backlog: 1024
 
 
pid pid_file
stderr_path err_log
stdout_path log_file
 
 
preload_app true
 
 
before_exec do |server|
  ENV['BUNDLE_GEMFILE'] = root_path + '/Gemfile'
end
 
 
before_fork do |server, worker|
  if File.exists?(old_pid) && server.pid != old_pid
    begin
      Process.kill('QUIT', File.read(old_pid).to_i)
    rescue Errno::ENOENT, Errno::ESRCH
      puts "Send 'QUIT' signal to unicorn error!"
    end
  end
end

8.nginx.conf的配置

http {
 
  include mime.types;
 
  default_type application/octet-stream;
 
  sendfile on;
 
  keepalive_timeout 0;
 
  upstream app_server {
    # fail_timeout=0 means we always retry an upstream even if it failed
    # to return a good HTTP response (in case the Unicorn master nukes a
    # single worker for timing out).
 
    # for UNIX domain socket setups:
    server unix: /path/to/app/tmp/sockets/socket fail_timeout=0;
  }
 
  server {
        listen 8080 default;
        return 403; 
  }
 
  server {
    listen 8080;
 
    server_name www.explame.com;
 
    location / {
      proxy_pass http://app_server;
    }
 
    # Rails error pages
    error_page 500 502 503 504 /500.html;
    location = /500.html {
      root /path/to/app/current/public;
    }
  }
}

nginx反向代理tomcat提示13 permission denied while connecting to upstream

setsebool -P httpd_can_network_connect 1

在进行Nginx+Tomcat 负载均衡的时候遇到了这个权限问题,在error.log日志中,我们可以看到如下:

connect() to 127.0.0.1:8080 failed (13: Permission denied) while connecting to upstream,

经过一番检查以及google,应该是SeLinux的导致的。可以选择一些两种方式进行:

1、关闭SeLinux,可以查看以下文章:

CentOS下查看SeLinux状态及关闭SeLinux

2、执行下面的命令

setsebool -P httpd_can_network_connect 1

Install Ruby on Rails with RVM on CentOS 7

不要用root权限安装rvm 及 ruby rails等相关工具。
———————-
1.curl -L https://get.rvm.io | bash -s stable
2.rvm list known列出所有版本
3.rvm install ruby-2.4.1
4.rvm alias create default current ruby-2.4.1
5.rvm alias create default ruby-2.4.1 重启后才能调用ruby命令,生效。或者source ~/.bash_profile也生效
6.gem install bundle

ruby开发文档

ruby开发文档
http://doc.rubyfans.com/rails/v5.0/
model generator
https://github.com/rails/rails/blob/master/railties/lib/rails/generators/rails/model/USAGE

redmine的启动脚本

Docker守护进程和名字
docker run –name=redmine -it -d
————–

#!/bin/sh
 
mode=$1
 
dockerd_current=`ps -ef | grep "dockerd-current"| grep -v grep`
portainer=`ps -ef | grep "/redmine/redmine/config/unicorn.rb"| grep -v grep`
 
case "$mode" in
   'start')
	echo "it's ready to start op...."
	if test -n "$dockerd_current"; then
		echo "---the docker.service had already started.."
	else
		`sudo systemctl start docker.service`
	fi
 
	if test -n "$portainer"; then
		echo "---the portainer had already started.."
	else
		`sudo docker stop /redmine`
		`sudo docker rm /redmine`
		`sudo docker run --name=redmine -it -d --env='DB_ADAPTER=mysql2' --publish=10083:80 --env='REDMINE_PORT=10083' --env='DB_HOST=192.168.11.130' --env='DB_NAME=redmine_production'  --env='DB_USER=redmine' --env='DB_PASS=123456' --volume=/srv/docker/redmine/redmine:/home/redmine/data sameersbn/redmine:3.4.2`
	fi
	echo 'success to start.'
	echo '---1--you can test redmine by way bellow----'
	echo 'http://localhost:10083'
	echo 'user:admin   password:123456'
	;;
   'stop')
	echo "it's ready to check process..."
	`sudo systemctl stop docker.service`
	echo 'success to kill.'
	;;
    *)
	basename=`basename "$0"`
	echo "Usage: $basename  {start|stop}  [ server options ]"
	exit 1
	;;
esac
exit 1

npm的本地缓存npm_lazy方案

具体安装流程参考官网:
1.http://mixu.net/npm_lazy/#installation
2.http://mixu.net/npm_lazy/#configuration

1.安装
npm install -g npm_lazy
2.修改配置,其路径为AppData\Roaming\npm\node_modules\npm_lazy\config.js。
  // external url to npm_lazy, no trailing /
  externalUrl: 'http://localhost:8972',
  // registry url with trailing /
  // remoteUrl: 'https://registry.npmjs.com/',
  remoteUrl: 'https://registry.npm.taobao.org/',
  // bind port and host
  port: 8972,
  host: '0.0.0.0',
3.启动服务
npm_lazy
4.配置npm的镜像路径为。
 // npm config set registry https://registry.npm.taobao.org
 npm config set registry http://localhost:8972
5.npm install

检查是否成功

Angular安装教程及npm使用淘宝镜像

按以下方式设置淘宝镜像,不要使用cnpm,因为cnpm和npm在node_module的目录结构会不一样。建议只使用淘宝的镜像则可。

npm config set registry http://registry.cnpmjs.org
或
npm config set registry https://registry.npm.taobao.org
检查镜像,设置是否正确
npm config list
返回结果,形如下:
D:\RubymineProjects>npm config list
; cli configs
user-agent = "npm/3.10.10 node/v6.11.3 win32 x64"
 
; userconfig C:\Users\guowen.he\.npmrc
registry = "https://registry.npm.taobao.org/"
 
; builtin config undefined
prefix = "C:\\Users\\guowen.he\\AppData\\Roaming\\npm"
 
; node bin location = C:\Program Files\nodejs\node.exe
; cwd = D:\RubymineProjects
; HOME = C:\Users\guowen.he
; "npm config ls -l" to show all defaults.

有时安装进度,好像很久都没有变化似的,可以使用以下通过检查node的网络流量是否有变化,来确定是否仍在工作,如果没有该进程很久都没有接收到流量数据,则可以重新安装。

如果曾经设置过淘宝cnpm对象,则会导致new project会失败,可使用以下命令修改为npm
ng set –global packageManager=cnpm
改为
ng set –global packageManager=npm
————————
1.安装python2.7.x,Angular的某些组件会使用它。
2.安装angular组件

因为angular-cli是用typescript写的,所以要先装这两个
npm install -g typescript typings
npm install -g @angular/cli   ,若观察到node的接收到的数据流量慢慢变小,最后差不多为0,则代表网络已经断开,可用Ctrl+C强制停止,重新执行该命令,该命令可多次停止并重新执行。
ng -v,检查是否安装成功
 
----
如果你之前安装失败过,最好在安装angular-cli之前先卸载干净,用以下两句:
npm uninstall -g angular-cli
npm cache clean 
可能新版本会提示使用npm cache verify删除,可能删除不成功,强制删除
npm cache verify --force

最后执行ng -v时,显示如下,则代表安装成功了。

ruby的路由配置

http://guides.rubyonrails.org/routing.html

Rails.application.routes.draw do
  # For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html
  root "post#index"
  get "/post/wellcome", to:"post#wellcome"
  resources :post
end