Parker Smith Software
3133 Brownsboro Rd. 
Louisville, KY 40206

You can send commands to a remote host using SSH alone as shown here, but since this is an interactive console session I used ruby to listen for the console prompts and enter the correct response.  See below:

Here's a nice little code snippet that I placed in the buggy function to see who was calling it:

1) This is our test string:

MyStaticClass.randomMethod().someFunction( BlahClass.MY_CONSTANT ).addEventListener

which we want to find and replace to be this:

(MyStaticClass.randomMethod().someFunction(BlahClass.MY_CONSTANT) as MyNewClass).genericObject.addEventListener
2) This is the full regex notation (which I was test matching in ruby): 

/^MyStaticClass\.randomMethod\(\)\.someFunction\((.+)\).addEventListener$/x

With this regex there is 1 match capture:  BlahClass.MY_CONSTANT.  You can use the various captures in a replacement string by providing the replacement string but inserting $X where you want the capture inserted, and where "X" is the capture instance, so in this case it is $1.

I was able to do a regex find and replace in TextMate like this:

Find:

^MyStaticClass\.randomMethod\(\)\.someFunction\((.+)\).addEventListener$

Replace:

(MyStaticClass.randomMethod().someFunction($1) as MyNewClass).genericObject.addEventListener

However no such luck in Flash Builder.  After some messing around I found out that Eclipse doesn't want the beginning and end line notations, so THIS works in Eclipse:

Find: 

MyStaticClass\.randomMethod\(\)\.someFunction\((.+)\).addEventListener

Replace:

(MyStaticClass.randomMethod().someFunction($1) as MyNewClass).genericObject.addEventListener ]]> brian@artifexsoftware.com (Brian Webb) http://www.parkersmithsoftware.com/blog/post/32-regex-find-and-replace Tue, 26 Oct 2010 00:00:00 -0400 http://www.parkersmithsoftware.com/blog/post/32-regex-find-and-replace http://feedproxy.google.com/~r/parkersmith/~3/VS2Wp-t-1Hg/31-web-hosting-explained What is this "hosting" anyway?

Wikipedia says: "Web hosting is a service that allows individuals and organizations to make their own website available via the World Wide Web".  Basically if you want to have your website online you need to put it somewhere that people can get to it, this is always going to be on a server connected to the internet.

The scope of hosting service varies widely but can generally be classified into 3 groups:  Shared Hosting, Virtual Private Server (VPS) Hosting, and Dedicated Server Hosting.

Shared Hosting
In a shared hosting environment there are multiple websites all sharing the same resources, often there will be 1 server hosting hundreds of simple websites.  The advantage to this is that cost can be decreased because you are sharing resources with other people.  The disadvantage here is that you are essentially overselling those resources again and again.  If any 1 of the websites on the shared server starts using more resources (for example if they have a traffic increase) all the other sites have less available.  So your site could be really slow someday because someone else is getting a lot of traffic.

Dedicated Server Hosting
With a dedicated server it is pretty much just like it sounds. You have your own physical server that is designated for your use only.  You have complete utilization of all the machines resources from processing power, and memory to hard drive space, no other websites will share the server unless they are yours and you want that.  Sometimes you will purchase the hardware yourself outright and other times you'll lease it from the hosting provider.  Generally it is better to lease because the hosting provider will maintain the hardware and replace parts if they go bad.  The advantage of a dedicated server is that you have all the power of a single machine to yourself.  The disadvantage lies in hardware failure.  If a hard drive or power supply goes out or some other mechanical failure happens your server could go down until the hardware is repaired, in best case scenarios this can often be 24-48 hours and hopefully the failure didn't cause any data loss.  It is possible to get servers that have redundant hard drives and other parts to have a failsafe against hardware failure, but those servers are much more expensive.

Virtual Private Server (VPS) Hosting
VPS hosting is somewhat of a mix between Shared and Dedicated taking all the good parts and few if none of the bad.  The process of VPS hosting is based on a technology called "Virtualization" in which the resources of a host machine are divided amongst many virtual machines which run on the host.  The host machines are often very high end powerful servers that would be overkill for use as a Dedicated Server, however through virtualization you can essentially have multiple dedicated servers by dividing the resources.

VPS hosting doesn't suffer from the same disadvantages as Shared Hosting because with a VPS the resources are fixed.  If a VPS is given 1 Gigabyte of memory it is there for it to use and restricted from others even if it only ever uses 1/4 of that.

Hardware upgrades are a significant advantage with a VPS.  If the processing power, memory or storage space needs to be increased it only takes a few clicks and it is done.  With Dedicated servers the hardware must be bought, information copied over if necessary, the server must be shut down, hardware installed and the brought back up for any post installation tasks. 

Some people might be thinking right about now "don't the host machines need hardware maintenance sometimes too?"  The answer is yes, but through a technology called "Live Migration" the virtual machines can be moved from one host to another without any down time.  This makes maintenance on the hosts realy easy.

Another advantage of a VPS is the setup time.  With a dedicated server you need to order the machine, then install all the software and lastly install the physical machine into the data center and connect it to the internet.  With a VPS they can be setup from "templates" wich include all the necessary software and configurations, and because the amount of memory and disk space is just a setting a new VPS can be setup in mere minutes.

Using a programming framework allows you to develop software much faster because many of the common routines are built-in.  For example in web based software you will routinley need to access information stored in a database.  If you were writing the code from scratch you would need to figure out how to connect to and ask questions of the database, maybe even how you would handle errors.  In a web based development framework you would probably have a code library that handles all those functions which could be reused for each project.  Thus you'd save a lot of time because you wouldn't be writing the same code over and over.

Some common web development languages:

• Ruby
• PHP
• ASP
• C#
• VB
• Java

Some common web development frameworks:

• Ruby on Rails (Ruby)
• Code Igniter (PHP)
• CakePHP (PHP)
• ASP.NET (C#, VB and others)
• JSP (Java)
• JSF (Java)

Generally speaking now days most all websites are also web applications.  However a website that is just a website would be one that is "static" meaning that it doesn't do anything, it's pages are simply like those of a magazine, once they are created and put online they are the same every time you look at them.

A web application on the other hand has some kind of logic built in that does something, perhaps changing the content of a page when it is requested depending on certain factors.  This could be something as simple as showing the current date or as complex as showing the days orders on an ecommerce site.  Take weather.com for example:  you input your zip code and it tells you the weather in your area.  The content is customized based on your input.

Well in our business there are 2 classes of software:  custom and off the shelf.  An off the shelf software is one that has been pre-made for a general audience and a general purpose, some examples would include: QuickBooks, Microsoft Word, Adobe Reader etc.  A custom software is simply one that is created because a viable off the shelf solution doesn't exist, or it doesn't fit the client's needs entirely and can't be modified to do so.

A custom software doesn't have to be a desktop program that is installed on your computer, genreally there are 3 types of software installations: desktop (on your computer), mobile (on your phone) and web based (always accessable online via the internet).  Most commonly we work with web based softwares, these range from simple "content management systems" that allow a business to update their website to complex applications that manage the minute by minute operations of an entire company.

In short custom software is business automation by allowing a computer to do certain jobs faster and more effeciently thus allowing people to work on more interesting, productive and creative things.

We've been using a loft downtown as our physical office for a while now, but the thing is, we don't actually need it.  Sure, a bricks and mortar structure is necessary for a lot of businesses.  But we do almost all of our work, project management and administration online.  We’ve been working virtually, in a sense, for a long time. 

One of the primary reasons for that is our staff.  Most of our employees are located in other cities across the country.  Having the flexibility of a "virtual office" has allowed Parker Smith to move beyond the limits of a physical location and to expand our hiring choices.  Sometimes you meet people who would make model employees, but they live hundreds of miles away and have no desire to move.  For us, that's okay.  When we hire someone, talent and skills are key, not location.

Our virtual business style also increases the productivity of our staff because time is saved from zero commuting.  And our employees are happy working at home, not having to sit in traffic or dress up.

We utilize the many wonders of modern technology to conduct our business virtually - video chatting, instant messaging, you name it.  We may not sit right next to them, but we are in constant contact with all of our employees.

When we acquired the loft downtown, we thought it was necessary because we expected to host client meetings there.  But in reality, we nearly always travel to our client's place of business.  It's easier for them, and it allows us to fully understand their company culture and operations.

And so, we recently found ourselves looking around our neat yet sparse office, and thought, "Hey! This is dumb!"  So we ditched it.

begin loc_banner = "#{RAILS_ROOT}/public/images/#{File.basename(_banner_path)}" file_banner = File.new(loc_banner) temp_banner = Tempfile.new("#{Digest::SHA1.hexdigest(Time.now.to_s)}.jpg") while !file_banner.eof? temp_banner.write file_banner.read end self.banner = temp_banner #set the paperclip attachment here rescue puts "Couldn't set image #{self.id}" end

Note that thiscode would need to require "digest/sha1"

For example. We're really picky about having clean HTML, so we always put a comment at the closing tag. In any HTML, ERB, or other template file hitting CMD + SHIFT + < pastes the following code:

When this code is pasted in the "div" is automatically highlited, if you wanted a div just hit tab and it will highlight the "class". If not just type what you wanted, maybe a "span" tag. When you change the tag type that closing tag will automatically get changed as you type. When you have hit tab to move to the "class" if you didn't want a class attribute just type what you wanted, maybe an "id". Hitting tab a 3rd time will put the cursor inside the quotes where you can name your attribute. Thus with 4 keystrokes (minus typing 'fubar') we can get this:

script/background start development

and then when you're all done.

script/background stop

Here's the code, just put it in script/background of your rails project:

require 'optparse' require 'rdoc/usage' require 'ostruct' require 'date' class App VERSION = '0.0.1' attr_reader :options def initialize(arguments, stdin) @arguments = arguments @stdin = stdin # Set defaults @options = OpenStruct.new @options.verbose = false @options.quiet = false @local_exists = false @remote_exists = false end #end initialize # Parse options, check arguments, then process the command def run if parsed_options? && arguments_valid? puts "Start at #{DateTime.now}\n\n" if @options.verbose output_options if @options.verbose # [Optional] process_arguments process_command puts "\nFinished at #{DateTime.now}" if @options.verbose else output_usage end end protected def parsed_options? # Specify options opts = OptionParser.new opts.on('-v', '--version') { output_version ; exit 0 } opts.on('-h', '--help') { output_help } opts.on('-V', '--verbose') { @options.verbose = true } opts.on('-q', '--quiet') { @options.quiet = true } opts.parse!(@arguments) rescue return false process_options true end # Performs post-parse processing on options def process_options @options.verbose = false if @options.quiet end def output_options puts "Options:\n" @options.marshal_dump.each do |name, val| puts " #{name} = #{val}" end end # True if required arguments were provided def arguments_valid? if @arguments.length >= 1 if @arguments[0] == "stop" true else if @arguments[1] == "development" || @arguments[1] == "test" || @arguments[1] == "production" true end end end end # Setup the arguments def process_arguments @start = @arguments[0] == "start" ? true : false @stop = @arguments[0] == "stop" ? true : false @env = @arguments.length > 1 ? @arguments[1] : nil end def output_help output_version RDoc::usage() #exits app end def output_usage RDoc::usage('usage') # gets usage from comments above end def output_version puts "#{File.basename(__FILE__)} version #{VERSION}" end def process_command if @start starling_command = <<-end_command cd #{File.dirname(__FILE__) + '/../'} && starling -d -P tmp/pids/starling.pid -q log/ end_command workling_command = <<-end_command cd #{File.dirname(__FILE__) + '/../'} && RAILE_ENV=#{@env} script/workling_client start end_command daemon_command = <<-end_command cd #{File.dirname(__FILE__) + '/../'} && RAILS_ENV=#{@env} lib/daemons/mailer_ctl start end_command starling_command.gsub!(/\s+/, " ") workling_command.gsub!(/\s+/, " ") daemon_command.gsub!(/\s+/, " ") puts "\nStarting Starling..." unless @options.quiet s_success = Kernel.system(starling_command) if !s_success && $?.exitstatus != 0 raise "!!! Starling startup failed !!!" else puts "Starling started successfully.\n\n" unless @options.quiet end sleep 1 puts "Starting Workling..." unless @options.quiet w_success = Kernel.system(workling_command) if !w_success && $?.exitstatus != 0 raise "!!! Workling startup failed !!!" else puts "Workling started successfully.\n\n" unless @options.quiet end elsif @stop starling_command = <<-end_command kill `ps -aef | grep starling | grep -v grep | awk '{print $2}'` end_command workling_command = <<-end_command cd #{File.dirname(__FILE__) + '/../'} && RAILE_ENV=#{@env} script/workling_client stop end_command daemon_command = <<-end_command cd #{File.dirname(__FILE__) + '/../'} && lib/daemons/mailer_ctl stop end_command starling_command.gsub!(/\s+/, " ") workling_command.gsub!(/\s+/, " ") daemon_command.gsub!(/\s+/, " ") puts "\nStopping Workling..." unless @options.quiet w_success = Kernel.system(workling_command) if !w_success && $?.exitstatus != 0 raise "!!! Workling shutdown failed !!!" else puts "Workling stopped successfully.\n\n" unless @options.quiet end sleep 1 puts "Stopping Starling..." unless @options.quiet s_success = Kernel.system(starling_command) if !s_success && $?.exitstatus != 0 raise "!!! Starling shutdown failed !!!" else puts "Starling stopped successfully.\n\n" unless @options.quiet end end end #end process_command end #end App Class # Create and run the application app = App.new(ARGV, STDIN) app.run

script/plugin install auto_complete

Now you can use the same auto complete functionality you are used to by adding the auto_complete_for declaration to your controller. One last gotcha is the route, you will have to add it to your routes.rb. One thing that may help if you have quite a few auto complete fields is to add a wild card route like so:

map.auto_complete ':controller/:action', :requirements => { :action => /auto_complete_for_\S+/ }, :conditions => { :method => :get } ]]> brian@artifexsoftware.com (Brian Webb) http://www.parkersmithsoftware.com/blog/post/20-auto_complete-in-rails-2 Mon, 15 Dec 2008 00:00:00 -0500 http://www.parkersmithsoftware.com/blog/post/20-auto_complete-in-rails-2 http://feedproxy.google.com/~r/parkersmith/~3/huL3dC9Z6nM/19-a-script-to-make-adding-new-git-repositories-easier My friend Jesse and I were trying to figure out a way to make the process of working with new GIT repositories easier. We wanted to create a new GIT repository locally, creating a new remote repository and adding the remote to the local so that you can push your development changes out for others to collaborate with. This involves a number of commands locally, then logging into your server, creating folders and git repositories there, then adding the remote repository to your local copy. Here is our current workflow:

#locally git init git add . git commit -m "initial import" #remote server cd /var/git mkdir newproject.git && cd newproject.git git --bare init #locally git remote add origin ssh://user@domain.com:35432/var/git/newproject.git git push origin master

That isn't a ton of work but it is a repetitive task that could be simplified. We started with some ideas of shell scripts and I ended up creating a script in Ruby that handles everything. It is called GNR which represented GIT - New - Repository when we came up with the concept. The script does all the commands above for you. Lets look at an example.

#create a new dummy rails project rails newproj gnr newproj ssh://user@domain.com:35432/var/git/newproj.git

That's it. Now we can CD into the newproj directory and start working. There are a couple assumptions that this script makes though:

1. You are using public/private RSA keys to login to your SSH server without passwords
2. Your user in the remote repo URL string (user@domain.com) has privileges to be able to write to the directory where your repositories are stored (/var/git in this example)

So here is the code:

require 'optparse' require 'rdoc/usage' require 'ostruct' require 'date' class App VERSION = '0.0.1' attr_reader :options def initialize(arguments, stdin) @arguments = arguments @stdin = stdin # Set defaults @options = OpenStruct.new @options.verbose = false @options.quiet = false @local_exists = false @remote_exists = false end #end initialize # Parse options, check arguments, then process the command def run if parsed_options? && arguments_valid? puts "Start at #{DateTime.now}\n\n" if @options.verbose output_options if @options.verbose # [Optional] process_arguments process_command puts "\nFinished at #{DateTime.now}" if @options.verbose else output_usage end end protected def parsed_options? # Specify options opts = OptionParser.new opts.on('-v', '--version') { output_version ; exit 0 } opts.on('-h', '--help') { output_help } opts.on('-V', '--verbose') { @options.verbose = true } opts.on('-q', '--quiet') { @options.quiet = true } opts.parse!(@arguments) rescue return false process_options true end # Performs post-parse processing on options def process_options @options.verbose = false if @options.quiet end def output_options puts "Options:\n" @options.marshal_dump.each do |name, val| puts " #{name} = #{val}" end end # True if required arguments were provided def arguments_valid? true if @arguments.length >= 1 end # Setup the arguments def process_arguments @project_folder = @arguments[0] @repo = @arguments[1] ? @arguments[1] : nil end def output_help output_version RDoc::usage() #exits app end def output_usage RDoc::usage('usage') # gets usage from comments above end def output_version puts "#{File.basename(__FILE__)} version #{VERSION}" end def process_command FileUtils.cd(@project_folder, :verbose => @options.verbose) do begin FileUtils.cd(".git", :verbose => @options.verbose) do @local_exists = true puts "Local repository already exists" unless @options.quiet config = File.new("config").read @remote_exists = true if config =~ /remote "origin"/ end rescue %x[git init] %x[git add .] %x[git commit -m "Created initial local repo"] #ssh to server and make new repo.git if @repo #get the repo string into usable vars user = @repo.gsub("ssh://","").split("@")[0] domain = @repo.gsub("ssh://","").split("@")[1].split(":")[0] port = @repo.gsub("ssh://", "").split(":")[1].split("/")[0] remote_repo = @repo.gsub("ssh://", "").split(":")[1][@repo.gsub("ssh://", "").split(":")[1].index("/"), @repo.gsub("ssh://", "").split(":")[1].length] root_folder = remote_repo[0,remote_repo.rindex("/")] repo_folder = remote_repo[remote_repo.rindex("/")+1, remote_repo.length] repo_string = %(ssh://#{user}@#{domain}:#{port}#{root_folder}/#{repo_folder}) commands = ["cd #{root_folder}", "mkdir #{repo_folder}", "cd #{repo_folder}", "git --bare init"] #ssh into the server and create the remote repo ssh_string = %(ssh -fCT #{user}@#{domain} -p #{port} "#{commands.join(" && ")}") Kernel.system "#{ssh_string}" #add the remote repo to the local repo Kernel.system "git remote add origin #{repo_string}" #push the local to the remote %x[git push origin master] end #end if @repo end #end rescue end #end FileUtils.cd end #end process_command end #end App Class # Create and run the application app = App.new(ARGV, STDIN) app.run

alias memcached_start='/opt/local/bin/memcached -d -m 64 -u www -l 127.0.0.1 -p 11211' alias memcached_stop='sudo killall memcached' #ssh alias connect='ssh -p 29876 ' #top alias tu='top -o cpu' #cpu alias tm='top -o vsize' #memory #git alias gb='git branch' alias gba='git branch -a' alias gcv='git commit -v' alias gcm='git commit -m' alias gd='git diff | mate' alias gl='git pull' alias gp='git push' alias ga='git add' alias gaa='git add . && echo "git added ."' alias gpa='echo "running: git push --all" && git push --all' alias gst='git status' #textmate alias et='mate .&' alias ett='mate app config lib db public test vendor/plugins &' #ruby alias att='autotest' #mysql alias mysql='/usr/local/bin/mysql/mysql' alias mysqladmin='/usr/local/bin/mysql/mysqladmin' alias mysqlstart='sudo /usr/local/bin/mysql/mysqld_safe &' alias mysqlstop='/usr/local/bin/mysql/mysqladmin -u root -p shutdown' alias sql='mysql -u root -p'

After editing the file you can either quit and restart your terminal, or you can run:

source ~/.bash_profile

Now you have all these really cool alias commands that make your workflow really fast. For example, say you have been working on some code and need to add, commit, and push the code to the origin server. Use the aliases....

gaa gcm "added foo bar feature" gpa ]]> brian@artifexsoftware.com (Brian Webb) http://www.parkersmithsoftware.com/blog/post/18-improve-your-workflow-with-aliases Thu, 06 Nov 2008 00:00:00 -0500 http://www.parkersmithsoftware.com/blog/post/18-improve-your-workflow-with-aliases http://feedproxy.google.com/~r/parkersmith/~3/CLnDRSA6Ryk/15-parker-smith-gets-office-space-in-glassworks-building amanda@parkersmithsoftware.com (Amanda Webb) http://www.parkersmithsoftware.com/blog/post/15-parker-smith-gets-office-space-in-glassworks-building Wed, 05 Nov 2008 00:00:00 -0500 http://www.parkersmithsoftware.com/blog/post/15-parker-smith-gets-office-space-in-glassworks-building http://feedproxy.google.com/~r/parkersmith/~3/JP45KjtcvME/17-remote-execution-of-commands-via-ssh Often when we have a long list of commands that we need to run on a remote server we'll use Capistrano to do this. Especially if the tasks are related to a project and we'll be moving files to the server, creating directories, restarting processes etc. But what if the task to be completed on the remote server isn't that complex, maybe just a couple commands. In this application Capistrano seems a little overkill, but at the same time we don't want to login and execute the commands manually, there is a better way. Lets see how...

For this example we'll be running commands for an OpenSSH server, and we have a password-less login enabled through the use of public/private keys. Enough talk, how do we do it, well we start with the SSH command and some options

ssh -fCT user@domain.com pwd

Lets look at the options and what they mean:
-f = Tells SSH to close after the session is established
-C = Tells SSH to use compression
-T = Means that no terminal session will be started

So the above command will login to the remote server via SSH and execute the 'pwd' command and the output will be displayed in the terminal window. That is cool, but it is a pretty simple example, its not often that we are running 'pwd' remotely, additionally at Parker Smith for security we never run SSH on the default port 22. To do this we can expand the example a little more using some more SSH options.

ssh -fCT user@domain.com -p 29746 "mkdir /home/user/test; ps wax >> /home/user/test/processes.txt"

Now this example is a bit more complex and could be more adaptable to your situation. We are logging into SSH running on port 29746 and we quote the commands separated by a semicolon. This particular command will login to the server, make a directory called test in the user's home directory, then list some processes and write them into a text file within that directory.

To take this another step further you could pass a shell script as the last argument instead of a command, and the list of commands in the script will be executed. This is a little easier than trying to put all the commands in a string.

The requirements are that the main load balancer needs to handle HTTP and HTTPS requests and it should automatically add or remove cluster nodes from the server pool as they become available, or unavailable. We can accomplish this by using the Nginx webserver.

We setup Nginx as you normally would perhaps using 6 or 7 workers, and you can setup the load balancing in the vhost config file. Instead of creating server pools of backend mongrels as you may have seen before, just make the items in the pool each point to a different server. In this example we actually store the IP locations in our /etc/hosts file.

upstream backend { server web1:80; server web2:80; server web3:80; server web4:80; server web5:80; } upstream secure { server web1:443; server web2:443; server web3:443; server web4:443; server web5:443; } server { listen 80; server_name www.domain.com domain.com; location / { # needed to forward user's IP address to rails proxy_set_header X-Real-IP $remote_addr; # needed for HTTPS proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header Host $http_host; proxy_redirect false; proxy_max_temp_file_size 0; proxy_pass http://backend; } #end location } #end server server { listen 443; ssl on; ssl_certificate /etc/ssl/ssl.pem/www.domain.com.pem; ssl_certificate_key /etc/ssl/ssl.key/www.domain.com.key; server_name www.domain.com domain.com; location / { # needed to forward user's IP address to rails proxy_set_header X-Real-IP $remote_addr; # needed for HTTPS #proxy_set_header X_FORWARDED_PROTO https; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header Host $http_host; proxy_redirect false; proxy_max_temp_file_size 0; proxy_pass https://secure; } #end location } #end server

Thats all there is to it, now this box will act as a front end load balancer in front of a number of other servers, adding a server is just 1 entry in each of the pools.

Note, be sure your log levels for Nginx are set to error only, since this Nginx instance will be handling a lot of traffic the logs can fill up really fast.

One side note, it probably isn't a good idea to send email this way in production mode since your app can stall while the email is being sent, and an MTA will have a mail queue to handle that.

To work with GMail we have to connect to SMTP through SSL, to do this we need to install the 'tlsmail' gem.

sudo gem install tlsmail Next create an initializer in config/initializers:

# config/initializers/email_config.rb if ENV['RAILS_ENV'] == "production" ActionMailer::Base.delivery_method = :smtp ActionMailer::Base.smtp_settings = { :address => '127.0.0.1', :port => 25, :domain => 'localhost' } else #setup tlsmail so we can send email through SSLed SMTP require 'tlsmail' Net::SMTP.enable_tls(OpenSSL::SSL::VERIFY_NONE) ActionMailer::Base.delivery_method = :smtp ActionMailer::Base.smtp_settings = { :address => 'smtp.gmail.com', :port => 587, :domain => 'yourdomain.com', :authentication => :plain, :user_name => 'maileraccount@yourdomain.com', :password => 'yourpassword' } end #end if

If you are using a Google Apps account then just replace the domain and username info with your own, if you are just using a gmail account the domain is gmail.com and the username is just your GMail id without the @gmail.com.

One thing to note, Google has limits on outgoing emails of about 100 per day per account to prevent people from using their service to send out spam.

# in deploy.rb default_run_options[:pty] = true

Setting the pty run option is what tells Capistrano to allow you to give response input to the script from the terminal, the next step is all in how you tell Capistrano to execute the command. Lets say that our task is to create a new user on the server and supply a password.

# deploy.rb set :new_user, "myuser" set :new_user_pw, "secret" desc "Setup a new user and supply the password" task :setup_user do run "useradd -m -d /home/#{new_user} -s /bin/bash #{new_user}" run "passwd #{new_user}" do |ch, stream, out| ch.send_data "#{new_user_pw}"+"\n" if out =~ /Enter new UNIX password:/ ch.send_data "#{new_user_pw}"+"\n" if out =~ /Retype new UNIX password:/ end end

Lets take a look at the code above, first we set variables for the new username and their password, this is what will get sent to the server in the command to create a new user. Next is the setup_user task, in this particular example we are executing this task as root, perhaps this is the first time you have setup any users on the new machine, if not you could just change the "run" statements to "sudo".

The second command in the task runs the 'passwd' command, grabs the output, and sends information back. The 'out' variable is the output from the server prompt, we use a REGEX pattern to match what the prompt is, so we can make a decision on what to send back.

Thats it, now to setup your new user just run:

cap setup_user

If you want to run the command with a different user or port, just run your cap command like this:

cap setup_user -s user=root -s port=22 ]]> brian@artifexsoftware.com (Brian Webb) http://www.parkersmithsoftware.com/blog/post/12-respond-to-server-prompts-in-capistrano Thu, 10 Jul 2008 00:00:00 -0400 http://www.parkersmithsoftware.com/blog/post/12-respond-to-server-prompts-in-capistrano http://feedproxy.google.com/~r/parkersmith/~3/h4-nhHC5nVE/11-capistrano-with-a-svn-repon-on-the-deploy_to-server Sometimes when you deploy with Capistrano you have just one server that acts in many roles (web, app, database all in one). When I have a client that has a single server for a single app I'll often setup an SVN repo to be accessed via svn+ssh. This causes a little bit of a hickup when you try to deploy with Capistrano because you need to tell the server to checkout the code from itself, but that isn't the same access pattern you need when you are committing things to the svn as a developer. Of course you could deploy_via :copy but that takes a bit longer, an easier route is to have one SVN access pattern for the server to checkout the code, and a different one for yourself as a remote machine. Here is how:

Here is an example deploy.rb file.

require 'mongrel_cluster/recipes' # setup vars used later in the script set :application, "yourdomain_com" set :user, "brian" set :runner, user set :main_server, "www.yourdomain.com" # source code repository set :local_repository, "svn+urdomainssh://www.yourdomain.com/repository/#{application}/trunk" set :repository, "file:////repository/yourdomain_com/trunk" # ssh port is 29361 set :port, 29361 # set the location for the app on the server set :deploy_to, "/var/www/apps/#{application}" set :deploy_via, :checkout # setup servers set :domain, main_server role :app, main_server role :web, main_server role :db, main_server, :primary => true # post deploy tasks desc "Link in the production symlinks" task :after_update_code do # link the database.yml file run "ln -nfs #{shared_path}/config/database.yml #{release_path}/config/database.yml" end #end after_update_code after "deploy", "deploy:cleanup"

Notice the directives :local_repository and :repository, the first tells Capistrano how to access the source code repository from your local machine (the one you are deploying code from). The second tells it how to access the repository from the server. We use a local file checkout on the server since we don't want to have to mess with private keys, and self referential connections on the server.

ALTER TABLE {table_name} AUTO_INCREMENT = {new_value}; ]]> brian@artifexsoftware.com (Brian Webb) http://www.parkersmithsoftware.com/blog/post/10-resetting-the-auto_increment-counter-in-mysql Wed, 28 May 2008 00:00:00 -0400 http://www.parkersmithsoftware.com/blog/post/10-resetting-the-auto_increment-counter-in-mysql http://feedproxy.google.com/~r/parkersmith/~3/5dSt14Xq-Cc/9-max_allowed_packet-mysql-error-explained I was doing some work where I needed to run some heavy queries on a database using the production data. Naturally I made a backup of the database and the plan was to restore it to my local MySQL instance on my development box and then run my tests. I hit a couple snags, and in an effort to document everything that I run into that requires some gumshoeing here is how I fixed it.

I read a bunch of people saying you could use –max_allowed_packet=100M in the command line but I had no luck with this. I also found some people who said you could edit my.cnf to put the setting there but the location and existence of this file appears to be different per the platform and installation method for MySQL. The end result is to update the setting directly at the mysql prompt. So:

mysql> SET GLOBAL max_allowed_packet = 16 * 1024 * 1024; ]]> brian@artifexsoftware.com (Brian Webb) http://www.parkersmithsoftware.com/blog/post/9-max_allowed_packet-mysql-error-explained Thu, 15 May 2008 00:00:00 -0400 http://www.parkersmithsoftware.com/blog/post/9-max_allowed_packet-mysql-error-explained