setup.exe and run itI will assume that Cygwin will be installed intoC:\Programs\Cygwin. Do not install Cygwin into a folder that contains a space character (C:\Program Files). If you do so, you will face many random and unexpected troubles.
C:\cygwin\Cygwin.bat)ssh-host-configsshd accountcyg_server).cyg_server.mkpasswd -cl > /etc/passwd
mkgroup --local > /etc/group
net start sshdssh localhost from Cygwin Bash Shell.exit.C:\Program Files\Java.). If you have a previous Java installation with a space-using filename, reinstall it now.C:\java\hbase../conf/hbase-env.sh in HBase directoryexport JAVA_HOME=/cygdrive/c/java/jdk7
export HBASE_CLASSPATH=/cygdrive/c/java/hbase/lib/zookeeper-3.4.3.jar
./src/main/resources/hbase-default.xml to ./conf./conf/hbase-default.xml in HBase directoryhbase.rootdir to /tmp
This will resolve into C:\tmp on Windows. We will create it later.
hbase.tmp.dir to C:/programs/cygwin/root/tmp/hbase/tmp
This also assumes that Cygwin is installed intoC:\programs\cygwin.
hostname from shell or from System Properties | Computer Name tab. For example, my PC has hostname rn-PC.hbase.zookeeper.quorum to rn-PC instead of localhostWindows 64-bit seems to have trouble resolvinglocalhostto127.0.0.1.
hbase.defaults.for.version.skip to true instead of falseThis will disable weird version warnings. We are actually running HBase from “uncompiled” source tree, therefore some config files get unprocessed. Despite the fact that HBase is being built by Maven, it is heavily depending on Linux tools and building requires lots of hacking. Fortunately, it is not necessary.
mkdir -pv /root/tmp/hbase/data
mkdir -pv /cygdrive/c/tmp
chmod 777 /root/tmp/hbase/data
chmod 777 /cygdrive/c/tmp
cd /cygdrive/c/java/hbase
./bin/start-hbase.sh/
$ ./bin/start-hbase.sh
rn@127.0.0.1's password:
127.0.0.1: starting zookeeper, logging to /cygdrive/c/java/hbase/bin/../logs/hbase-rn-zookeeper-rn-PC.out
starting master, logging to /cygdrive/c/java/hbase/bin/../logs/hbase-rn-master-rn-PC.out
rn@localhost's password:
localhost: starting regionserver, logging to /cygdrive/c/java/hbase/bin/../logs/hbase-rn-regionserver-rn-PC.out
C:\java\hbase\log)../bin/stop-hbase.sh.
./bin/start-hbase.sh/./bin/hbase shell
create 'test', 'data'
list
put 'test', 'row1', 'data:1', 'value1'
scan 'test'
disable 'test'
drop 'test'
exit.
 |
| Add caption |
Whether it is retrieving an RSS feed, or performing some maintenance operations on your system or a Rails app, an easy to use scheduler is a must have. Motivated by this need, I did some scouring and came up with a few nifty ways to accomplish the task. Now, before we go on, it’s worth mentioning that all *nix based systems have the advantage of a cron daemon which can perform this job quiet effectively. However, building standalone scripts is not always the best way to get things done, hence there are some valid cases where replicating this functionality can, in fact, be very useful.
The most obvious way to schedule a task from within your program is to either loop it forever with a periodic sleep interval, or launch a separate thread which will perform the same job:
require 'fastthread'
t = Thread.new do
while true do
p 'perform task'
sleep 5
end
end
t.join # wait for thread to exit (never, in this case)
Create a new thread, perform the task, sleep for 5 seconds, and repeat forever. Launching one of these inside a Tier IV datacenter will ensure that your tasks are executed until the next nuclear winter. (Or, until your thread crashes - whichever is more likely!)
While threads are easy to use, they are still not very intuitive. After some searching, I stumbled across the OpenWFEru project, which implements a really nifty standalone-ready scheduler. Take a look yourself:
require 'openwfe/util/scheduler'
include OpenWFE
scheduler = Scheduler.new
scheduler.start
# Simple usage
scheduler.schedule_every('2s') { p 'every 2 seconds' }
scheduler.schedule_every('5m') { p 'every 5 minutes' }
scheduler.schedule_every('1d') { p 'every day' }
# More fine-grained control + schedule task once.
scheduler.schedule_in('3d2m10s') do
p 'after 3 days 2 minutes and 10 seconds stopping the scheduler and exiting...'
scheduler.do_stop
end
# Cron-string scheduling. There is something for everyone here!
scheduler.schedule('1-60 * * * *') do
p 'perform task'
end
scheduler.join
OpenWFEru scheduler is now also available as a standalone gem thanks to John Mettraux.
Each call to the scheduler queues your request on the main thread, which then spawns a separate thread for each task when the time is right. It’s definitely quite a bit cleaner, but the rich parse engine is by far the best part. Even a non-programmer will understand this code. Plus, and if thats your preference, you have the ability of providing a cron-like string! Also, it is important to note that if you schedule a task for every 2 seconds, but the task itself takes 3 seconds, then the job will be performed every 5 seconds! If you really do need 2 second intervals, simply create a new thread in your scheduled block, and let it run.
Finally, if you want to schedule tasks in Rails, then BackgrounDRB is your new best friend. Ezra wrote a great guide for it, and I highly recommend that you check it out. As of 0.2.1, backgroundrb added support for easy job scheduling via a yaml config file (conf/backgroundrb_schedules.yml). Here is a sample:
scheduled_task:
:class: :scheduled_task_worker
:worker_method: :do_work
:trigger_args:
:start: <%= Time.now + 10.minutes %>
:repeat_interval: <%= 1.hour %>
Note that you can have multiple workers, running at different intervals, simply duplicate the worker in your config and give it a different name. Then, call up the generator to create the file itself and navigate to lib/workers. Again, here is a sample implementation:
class ScheduledTaskWorker < BackgrounDRb::Worker::RailsBase
def do_work(args)
# RailsBase worker gives this class access to all ActiveRecord models.. go wild!
p 'perform task'
end
end
ScheduledTaskWorker.register
Thanks to http://openwferu.rubyforge.org/.. concepts were clear from this site
The first argument that begins with `-', `(', `)', `,', or `!' is taken to be the beginning of the expression; any arguments before it are paths to search, and any arguments after it are the rest of the expression. If no paths are given, the current directory is used. If no expression is given, the expression `-print' is used.
find exits with status 0 if all files are processed successfully, greater than 0 if errors occur.
A `\' character followed by any other character is treated as an ordinary character, so they both are printed.
Time fields:
Date fields:
A `%' character followed by any other character is discarded (but the other character is printed).
find /home -user joeFind every file under the directory /home owned by the user joe.
find /usr -name *statFind every file under the directory /usr ending in ".stat".
find /var/spool -mtime +60Find every file under the directory /var/spool that was modified more than 60 days ago.
find /tmp -name core -type f -print | xargs /bin/rm -fFind files named core in or below the directory /tmp and delete them. Note that this will work incorrectly if there are any filenames containing newlines, single or double quotes, or spaces.
find /tmp -name core -type f -print0 | xargs -0 /bin/rm -f
Find files named core in or below the directory /tmp and delete them, processing filenames in such a way that file or directory names containing single or double quotes, spaces or newlines are correctly handled. The -name test comes before the -type test in order to avoid having to call stat(2) on every file.
find . -type f -exec file '{}' \; Runs `file' on every file in or below the current directory. Notice that the braces are enclosed in single quote marks to protect them from interpretation as shell script punctuation. The semicolon is similarly protected by the use of a backslash, though ';' could have been used in that case also.
find / \( -perm -4000 -fprintf /root/suid.txt '%#m %u %p\n' \) , \Traverse the filesystem just once, listing setuid files and directories into /root/suid.txt and large files into /root/big.txt.
\( -size +100M -fprintf /root/big.txt '%-10s %p\n' \)
find $HOME -mtime 0Search for files in your home directory which have been modified in the last twenty-four hours. This command works this way because the time since each file was last modified is divided by 24 hours and any remainder is discarded. That means that to match -mtime
0, a file will have to have a modification in the past which is less than 24 hours ago.
find . -perm 664Search for files which have read and write permission for their owner, and group, but which other users can read but not write to. Files which meet these criteria but have other permissions bits set (for example if someone can execute the file) will not be matched.
find . -perm -664Search for files which have read and write permission for their owner and group, and which other users can read, without regard to the presence of any extra permission bits (for example the executable bit). This will match a file which has mode 0777, for example.
find . -perm /222Search for files which are writable by somebody (their owner, or their group, or anybody else).
find . -perm /220All three of these commands do the same thing, but the first one uses the octal representation of the file mode, and the other two use the symbolic form. These commands all search for files which are writable by either their owner or their group. The files don't have to be writable by both the owner and group to be matched; either will do.
find . -perm /u+w,g+w
find . -perm /u=w,g=w
find . -perm -220Both these commands do the same thing; search for files which are writable by both their owner and their group.
find . -perm -g+w,u+w
find . -perm -444 -perm /222 ! -perm /111These two commands both search for files that are readable for everybody (-perm -444 or -perm -a+r), have at least on write bit set (-perm /222 or -perm /a+w) but are not executable for anybody (! -perm /111 and ! -perm /a+x respectively)
find . -perm -a+r -perm /a+w ! -perm /a+x