How to start Solr automatically?

Question

At the moment I have to go to /usr/java/apache-solr-1.4.0/example and then do:

java -jar start.jar

How do I get this to start

Answer 1

Adding the following lines to my /etc/init.d/solr file works to support Red Hat Linux (I copied them from /etc/init.d/mysql after reading comments by others here).

# Comments to support chkconfig on Red Hat Linux
# chkconfig: 2345 64 36
# Description: A very fast and reliable search engine.

Answer 2

I answered this question once already, but that answer was for operating systems that used SysV and this one is for newer operating systems that are increasingly using systemd.

As in my other answer, there are three things you'll need to do here:

1. Create the script and put it in the right place.
2. Make the script start up properly on reboot.
3. Bonus: Make systemd logs persistent.

1. Creating the script and putting it in the right place

Here's a systemd unit file that you can use (these replace the SysV init files). Name it solr.service.

[Unit]
Description=Apache Solr
After=syslog.target network.target remote-fs.target nss-lookup.target

[Service]
Type=simple
Environment="XMX=2G"
WorkingDirectory=/usr/local/solr/example
ExecStart=/usr/bin/java -jar -server -Xmx${XMX} start.jar
Restart=on-failure
LimitNOFILE=10000

[Install]
WantedBy=multi-user.target

Note that there's a configuration in there for Solr's memory. You'll probably want to tweak that to your own purposes. If you have a number of variables you're passing to systemd, you can do that with the EnvironmentFile directive.

More documentation for these files is here.

2. Make the script startup properly at boot

This is fairly simple, but there are rules. To make it start at boot, put the file in /etc/systemd/system/solr.service. You cannot use a symlink in this directory, do not try.

Once that's in there, you can enable the daemon to run at boot with:

sudo systemctl enable solr

And you can start, stop, status it with:

sudo systemctl {start|stop|status} solr

3. Making systemd logs persistent

By default, systemd logs are not persistent and they are lost whenever you reboot the system. If that's not what you desire, you can make them persistent by creating a directory:

sudo mkdir -p /var/log/journal/

And then restarting the systemd journaling daemon:

sudo systemctl restart systemd-journald

Once that's complete, systemd's journaling daemon will receive all the stdout and stderr that Solr creates and it will get stored in a binary format under /var/log/journal/.

The way systemd handles logging is pretty neat and is worth studying if you're not familiar with it. In the meantime, just know that to read your log entries you'll need to use a new tool called journalctl. For example, this will follow your solr logs:

journalctl -u solr -f

And there are also flags for doing date-based filtering and things like that.

3.1 Tweaking the log files

Bonus section! If you want to tweak the log files, you can read all about it in the documentation here, but the defaults are actually very safe and sane (logs are compressed by default, can't grow too large, are rate limited, and are written to disk in batches).

Answer 3

Follow supermagic's comments, then follow this

http://codingrecipes.com/service-x-does-not-support-chkconfig

He says,

1 – Copy your script into /etc/init.d folder
2 – cd /etc/init.d
3 – chmod +x myscript
4 – Add these lines, including #, right after #!/bin/bash or #!/bin/sh:

# chkconfig: 2345 95 20
# description: Some description
# What your script does (not sure if this is necessary though)
# processname: myscript

Then you can do

chkconfig --add myscript

Answer 4

Check

man 5 crontab

See if @reboot is supported on the Linux system you are using.

Answer 5

There are three steps that you need to do here:

1. Create the script, make it executable, and put it in the right place.
2. Make the script start up properly on reboot.
3. Bonus: Set up a logrotation script so logs don't get out of control.

For number one, I've tuned supermagic's script from above. It was OK, but had a number of typos, lacked some functionality (status, restart), didn't use the daemon utility very effectively.

Here's my version of the script (make sure you have daemon installed for it to work):

#!/bin/sh

# Prerequisites:
# 1. Solr needs to be installed at /usr/local/solr/example
# 2. daemon needs to be installed
# 3. Script needs to be executed by root

# This script will launch Solr in a mode that will automatically respawn if it
# crashes. Output will be sent to /var/log/solr/solr.log. A pid file will be 
# created in the standard location.

start () {
    echo -n "Starting solr..."

    # start daemon
    daemon --chdir='/usr/local/solr/example' --command "java -jar start.jar" --respawn --output=/var/log/solr/solr.log --name=solr --verbose

    RETVAL=$?
    if [ $RETVAL = 0 ]
    then
        echo "done."
    else
        echo "failed. See error code for more information."
    fi
    return $RETVAL
}

stop () {
    # stop daemon
    echo -n "Stopping solr..."

    daemon --stop --name=solr  --verbose
    RETVAL=$?

    if [ $RETVAL = 0 ]
    then
        echo "done."
    else
        echo "failed. See error code for more information."
    fi
    return $RETVAL
}


restart () {
    daemon --restart --name=solr  --verbose
}


status () {
    # report on the status of the daemon
    daemon --running --verbose --name=solr
    return $?
}


case "$1" in
    start)
        start
    ;;
    status)
        status
    ;;
    stop)
        stop
    ;;
    restart)
        restart
    ;;
    *)
        echo $"Usage: solr {start|status|stop|restart}"
        exit 3
    ;;
esac

exit $RETVAL

Place this script at /etc/init.d/solr, make it executable, and you should be good with step one. You can now start/stop/restart/status a solr daemon with /etc/init.d/solr start|stop|restart|status

For step two, run the following on an Ubuntu machine (don't know about Redhat):

update-rc.d solr defaults

Once this is done, you're in pretty good shape, but you probably want to rotate the logs properly at some point, so here's a good config for the logs:

/var/log/solr/*.log {
  weekly
  rotate 12
  compress
  delaycompress
  create 640 root root
  postrotate
    /etc/init.d/solr restart
  endscript
}

Place that file in /etc/logrotate.d/solr, and you should be good to go, assuming logrotate is running (it usually is).

Answer 6

If you have root access to your machine, there are a number of ways to do this based on your system's initialization flow (init scripts, systemd, etc.)

But if you don't have root, cron has a clean and consistent way to execute programs upon reboot.

First, find out where java is located on your machine. The command below will tell you where it is:

$ which java

Then, stick the following code into a shell script, replacing the java path below (/usr/bin) with the path you got from the above command.

#!/bin/bash

cd /usr/java/apache-solr-1.4.0/example
/usr/bin/java -jar start.jar

You can save this script in some location (e.g., $HOME) as start.sh. Give it world execute permission (to simplify) by running the following command:

$ chmod og+x start.sh

Now, test the script and ensure that it works correctly from the command line.

$ ./start.sh

If all works well, you need to add it to one of your machine's startup scripts. The simplest way to do this is to add the following line to the end of /etc/rc.local.

# ... snip contents of rc.local ...
# Start Solr upon boot.
/home/somedir/start.sh

Alternatively, if you don't have permission to edit rc.local, then you can add it to your user crontab as so. First type the following on the commandline:

$ crontab -e

This will bring up an editor. Add the following line to it:

@reboot /home/somedir/start.sh

If your Linux system supports it (which it usually does), this will ensure that your script is run upon startup.

If I don't have any typos above, it should work out well for you. Let me know how it goes.