Basic WEBrick setup for local web server

ntk () — Tue, 17 Jun 2008 17:27:02 GMT

Put the following functions and aliases into your ~/.bash_login (or alternatives).





unset -f webrick_local



function webrick_local() { 



   declare root_dir="${HOME}/Desktop/www"



   /bin/mkdir -p "${root_dir}/WEBrickLog"

   /bin/chmod 0754 "${root_dir}" "${root_dir}/WEBrickLog"



   /usr/bin/touch "${root_dir}/WEBrickLog/webrick.pid" "${root_dir}/WEBrickLog/webrick_ruby.pid"

   /bin/chmod 0644 "${root_dir}/WEBrickLog/webrick.pid" "${root_dir}/WEBrickLog/webrick_ruby.pid"



#   /usr/bin/touch "${root_dir}/index.html"

#   /bin/chmod 0754 "${root_dir}/index.html"





/usr/local/bin/ruby <<-HEREDOC



   require 'webrick'

   require 'webrick/accesslog'

   include WEBrick



   require 'thread'

   require 'pp'



   root_dir = "${root_dir}"

   http_dir = File.expand_path(root_dir)



   File.open(http_dir + "/WEBrickLog/webrick_ruby.pid", "w") do |f|

      f.puts(Process.pid)

   end



   # cf. http://microjet.ath.cx/webrickguide/html/Logging.html

   webrick_log_file = File.expand_path(http_dir + "/WEBrickLog/webrick.log")

   #webrick_log_file = '/dev/null'  # disable logging

   webrick_logger = WEBrick::Log.new(webrick_log_file, WEBrick::Log::DEBUG)



   access_log_stream = webrick_logger

   access_log = [[ access_log_stream, WEBrick::AccessLog::COMBINED_LOG_FORMAT ]]



   system_mime_table = WEBrick::HTTPUtils::load_mime_types('/private/etc/httpd/mime.types.default')

   system_mime_table.store('rhtml', 'text/html')   # add a mime type for .rhtml files

   system_mime_table.store('php', 'text/html')

   system_mime_table.store('rb', 'text/plain')

   system_mime_table.store('pid', 'text/plain')

   #pp system_mime_table.sort_by { |k,v| k }



   server = WEBrick::HTTPServer.new(

     :BindAddress     =>    "localhost",

     :Port            =>    9090,

     :DocumentRoot    =>    http_dir,

     :FancyIndexing   =>    true,

     :MimeTypes       =>    system_mime_table,

     :Logger          =>    webrick_logger,

     :AccessLog       =>    access_log

   )



   server.config.store(:DirectoryIndex, server.config[:DirectoryIndex] << "default.htm")

   #pp server.config



   # cf. http://snippets.dzone.com/posts/show/5208

   class TimeServlet < HTTPServlet::AbstractServlet



      def do_GET(req, res)

         res['Content-Type'] = 'text/html'

         res.status = 200

         res.body = "Time: #{Time.now.to_s}" + "\n"

      end



      # cf. http://www.hiveminds.co.uk/node/244, published under the

      # GNU Free Documentation License, http://www.gnu.org/copyleft/fdl.html



      @@instance = nil

      @@instance_creation_mutex = Mutex.new



      def self.get_instance(config, *options)

         #pp @@instance

         @@instance_creation_mutex.synchronize { 

            @@instance = @@instance || self.new(config, *options) }

      end



   end





   # cf. http://ttripp.blogspot.com/2007/01/fun-with-http.html

   class PostDumper < WEBrick::HTTPServlet::AbstractServlet

  

      # Reload file for each request, instantly

      # updating the server with code changes 

      # without needing a restart.



=begin

      def PostDumper.get_instance( config, *options )

         load __FILE__

         PostDumper.new config, *options

      end

=end



      # cf. http://www.hiveminds.co.uk/node/244, published under the

      # GNU Free Documentation License, http://www.gnu.org/copyleft/fdl.html



      @@instance = nil

      @@instance_creation_mutex = Mutex.new



      def self.get_instance(config, *options)

         #pp @@instance

         @@instance_creation_mutex.synchronize { 

            @@instance = @@instance || self.new(config, *options) }

      end



      def do_GET( request, response )

         response.status = 200

         response['Content-Type'] = "text/plain"

         response.body = dump_request( request )

      end

  

      def do_POST( request, response )

         response.status = 200

         response['Content-Type'] = "text/plain"

         response.body = dump_request( request )

         response.body << request.body

      end

  

      def dump_request( request )

         request.request_line << "\r\n" <<

         request.raw_header.join( "" ) << "\r\n"

      end

   end



   server.mount("/dump", PostDumper)

   server.mount("/time", TimeServlet, {:FancyIndexing=>true})



   # handle signals

   %w(INT).each do |signal|

      trap(signal) { server.shutdown }

   end



   server.start



HEREDOC



return 0



}



export -f webrick_local



# start WEBrick alias

alias webrick='swr'



# start WEBrick

unset -f swr

function swr() {   

  declare webrick_pid_file="${HOME}/Desktop/www/WEBrickLog/webrick.pid"

  if [[ -e "${webrick_pid_file}" ]]; then echo "WEBrick already started!"; return 1; fi

  /bin/bash -c "webrick_local" &

  declare WEBRICKPID=$!

  mkdir -p "${HOME}/Desktop/www/WEBrickLog"

  echo $WEBRICKPID > "${HOME}/Desktop/www/WEBrickLog/webrick.pid"

  return 0

}

export -f swr



# quit WEBrick

unset -f qwr

function qwr() { 

   declare webrick_pid_file="${HOME}/Desktop/www/WEBrickLog/webrick.pid"

   declare webrick_ruby_pid_file="${HOME}/Desktop/www/WEBrickLog/webrick_ruby.pid"

   if [[ ! -e "${webrick_pid_file}" ]]; then echo "no such file: ${webrick_pid_file}"; return 1; fi

   declare PIDW=$(cat "${webrick_pid_file}" 2>/dev/null)

   declare PIDR=$(cat "${webrick_ruby_pid_file}" 2>/dev/null)

   kill -INT $PIDW 2>/dev/null || echo "no such PIDW: ${PIDW}"

   kill -INT $PIDR 2>/dev/null || echo "no such PIDR: ${PIDR}"

   rm -f "${webrick_pid_file}" "${webrick_ruby_pid_file}"

   return 0

}

export -f qwr



# quit WEBrick; cf. Job Control Commands, http://tldp.org/LDP/abs/html/x8816.html

###alias qwr='echo "quit WEBrick with ctrl-c ..."; fg %webrick 2>/dev/null'



alias openwww='/usr/bin/open http://localhost:9090'

alias wrlog='/usr/bin/open http://localhost:9090/WEBrickLog/webrick.log'





#----------------------------------------





source ~/.bash_login



webrick



openwww

wrlog

open http://localhost:9090 

open http://localhost:9090/WEBrickLog

open http://localhost:9090/WEBrickLog/webrick.log



open http://localhost:9090/time

open http://localhost:9090/dump



wrlog

qwr

Further information:

- WEBrick
- WEBrick RDoc
- What is WEBrick?
- Guide to using WEBrick for Rails development
- Dynamic WEBrick Servers in Ruby
- Gnome's Guide to WEBrick
- Running Servlets with WEBrick
- rsphandler
- URL rewriting with WEBrick

Python - randomLocal

whitetiger () — Thu, 20 Apr 2006 03:01:25 GMT

// Create a sample directory localIMGs



import os

import random



class localImages(object):

    

    def __init__(self, directory='/home/Foto'):

        

        self.directoryScan = directory # Cartella da cui cominciare a prelevare le foto

        self.directoryRemain = [self.directoryScan]

        self.filePath = {}

    

    def getRandomImages(self):

        '''

        Prelieva dal proprio disco delle immagini in maniera random...

        '''

        

        for i in range(5): # Scansiona 5 directory

            if len(self.directoryRemain) > 0:

                directory = random.choice(self.directoryRemain)

                self.directoryRemain.remove(directory)

                

                files = []

                

                try:

                    files = os.listdir(directory)

                except:

                    pass

                

                # Serve per aumentare il Random delle Foto

                # FIXME: cercare di aumentare questo random

                if len(files) > 0:

                    for i in range(len(files)/2):

                        files_remove = random.choice(files)

                        files.remove(files_remove)

                ##########################################

                

                for filename in files:

                    filepath = os.path.join(directory, filename)

                

                    if os.path.isdir(filepath):

                        self.directoryRemain.append(filepath)

                    elif os.path.isfile(filepath):

                        (name, ext) = os.path.splitext(filepath)

                        if ext.lower() in ('.jpg', '.gif'):

                            self.filePath[filepath] = 0

                  

        if len(self.directoryRemain) == 0: self.directoryRemain = [self.directoryScan]

        

    def downloadImages(self):

        '''

        Scarica nella cartella localIMGs le foto che vengono trovate nel disco...

        '''

        

        numberIMGs = len(self.filePath)

        posIMGs = 1

        

        for imageName in self.filePath:

            print '[' + str(posIMGs) + '/' + str(numberIMGs) + '] - ' + imageName

            fread = open(imageName, 'rb')

            fwrite = open('localIMGs' + os.sep + os.path.split(imageName)[1], 'wb')

            fwrite.write(fread.read())

            fread.close()

            fwrite.close()

            posIMGs += 1

                              

if __name__ == '__main__':

    

    test = localImages()

    

    test.getRandomImages()

    test.downloadImages()

    

    print 'Finito...'

Start MySQL with LOAD LOCAL INFILE enabled

offspinner () — Thu, 09 Feb 2006 16:07:02 GMT

// description of your code here



/opt/mysql/bin/mysql -u root -h mysql-server --local-infile=1

MySQL LOAD DATA LOCAL

offspinner () — Thu, 09 Feb 2006 16:06:14 GMT

// description of your code here



LOAD DATA LOCAL INFILE "/dc/elp/lionref/data/master/loggy.txt" INTO TABLE citations;

DZone Snippets: LOCAL code

Basic WEBrick setup for local web server

Python - randomLocal

Start MySQL with LOAD LOCAL INFILE enabled

MySQL LOAD DATA LOCAL