Currently My web Application is running on jboss 5.1 and we need to migrate it to jetty server..i am looking for a complete detail and steps to do the process...Thanks in advance
I don't think there exists a step by step document along the lines you are looking for. It largely depends on your web application how simple or hard the migration would be. If you are using EJB's for instance then you would have to also factor in the openejb integration we have some support for, if it is a straight war file then it is likely much easier. There are professional services from the jetty developers available to help if you like, you can google Webtide for that. I would recommend going straight to Jetty 9.1 though, the new distribution layout makes things a fair amount easier to separate things out.
Current documentation is here though: http://www.eclipse.org/jetty/documentation/current/
Related
I'm playing with Clojure/ClojureScript and I'm writing a web application. Everything is fine while I'm using ring as a development server.
The question is what container should I use for production? Should I use ring for production as well? Should I use Tomcat? Is there a recommended way to deploy a Clojure application? Can you point me to some documentation regarding this aspect?
Thanks!
There is nothing inherently different about deploying a java servlet that was written in Java vs. Clojure and all the Clojure web libraries and frameworks produce compatable servlets so you have many deployment options.
We use netty to run our ring based web application to great effect in production simply by running "lein run" from a system service. Many others choose to use lein uberwar to produce a war file and host that on tomcat. The specific hosting mechanism seems less relevant than the deployment process. All the JavaScript files are served from a CDN. Immutant is also a fun and very Clojure oriented choice with a strong "enterprisy" feel to it.
What strikes me as most important is building a repeatable build, including deployment. Pallet is a great way to go though it's got a bit of a learning curve.
There are a few options.
First one is easy: Heroku. They have a free tier that is ample for deployment and testing. I won't go into further detail on this, but I decided not to use Heroku anymore.
Another common option is Amazon AWS. I gather most apps on AWS use lein-beanstalk [sorry, no citation here]. Lein-beanstalk has been out for quite a while and appears to be well-maintained. It is also maintained by the same person who maintains Compojure.
I use a VPS. I set up the linux build with Nginx and deploy with git. So, basically, my flow is create the site, compile to lein uberjar, then deploy. I know that some people can and do use the leiningen "lien ring server" cantation on their apps and use many other configurations, such as Maven, Tomcat, deployment with Vagrant, etc, but I just run java -jar myApp-xxxxx on the server and it works great.
As far as documentation, there does appear to be a dearth of documentation on Clojure deployment specifically. Sort of have to bang your head against the wall and figure it out if you want to go the VPS route the first time you do it. I found that almost none of my issues involved Clojure specifically.
In development I use:
lein ring server
: then to compile it to a war file I use:
lein ring uberwar
: and just drop the resulting jar file into the Webapps directory and it works fine. I use Jetty by the way
I provide a web service, but sometimes I need to update my web service. When i update the source code, i need to stop the service, then install the new service package.
Here is the problem:
1 I really don't want to stop the service when updating
2 I just need to update some specific features. But now I have to update the whole package. This makes the updating process long and heavy.
I think EJB would be a solution. But i need more advice.
Any advice is appreciated
You may want to think on lines of dynamic class loading tools. One of the tools i am aware is JRebel. You might want to have a look at it.
Other opensource alternative is springloaded. But its still naive and under constant development.
I'm trying to setup a development environment for Ember.js that allows me to load js classess and handlebar templates from separate files (the way SC used to do it). Which is the recommended way to go? BPM or rake-pipeline?
Both rake-pipeline and BPM are deprecated and no longer maintained.
Continuing efforts are focused on a combination of ember-cli, ember-app-kit, and the related ember-appkit-rails. We're also excited about the development of Broccoli. The long term plan, as I understand it, is to have ember-cli serve as a front to either EAK or Broccoli.
The core team is using rake-pipeline for active projects but I'm told they do have plans to continue active development of BPM and are not abandoning it. Many people still use BPM for active projects.
Currently you can use BPM with Ember without any problems. I personally have taken interest in BPM and will keep www.getbpm.org is up-to-date with new releases of Ember until the core team gets to the point of actively maintaining it again. So right now BPM is community supported.
Nowadays, rake-pipeline, Bpm is not yet being supported.
Look at the AssetFile on the emberjs projects to see how must be configured using rake-pipeline and rake-pipeline-web-filters.
Is there a way to meet the following criteria in distributing a Web Service to Windows machines?
1) Automatic installation and configuration of the Web Server.
2) No configuration (or even awareness) of a Web Server required by the customer.
3) No prompts to download and install Java or .NET - especially anything after .NET 2.0; those installs / restarts can take forever!
In short, is there a way to deliver a single install process that installs the Web Server along with a simple web app without requiring lengthy installations of pre-requisites? Something for even the most non-technical of users?
.NET's WCF almost meets the requirements but getting .NET updated up to 3.0 / 3.5 is a lengthy process and can be a turn-off for customers, even if the install holds their hand through the whole thing.
Rubyscript2exe was also very close, but it is extremely touchy and out-dated.
I am open to any technology / programming language - just looking for the slickest distribution process for my customers that meets the above three criteria.
I've been doing quite a bit of research on this as it is extremely important to me that my users have a simple installation experience. Here are a few things that I've found:
UltiDev Cassini: Cassini is that convenient mini-server that runs when you debug your web apps from Visual Studio or Visual Web Developer. UltiDev Cassini builds on that and looks pretty promising. It offers support for all non-beta flavors of .Net and integrates right into Visual Studio. Most interesting to me is the ability to include as part of your installer. The only down side is that pesky .Net pre-requisite. I can handle helping users get installed up to 2.0, but the install process to move to 3.0 and 3.5 is way too heavy for the typical user.
RubyScript2Exe: I like the premise of an executable Rails app. However, I attempted to use this on a Mac and it is simply too outdated and requires too many workarounds for my tastes. It's too bad, because I love Ruby on Rails development.
Server2Go: This is my favorite of the three options. It is easily distributable (just send off a zip file) and has a lot of nice options. For example, you can configure it to leave the included Apache server running even after the browser closes - that is PERFECT for a nicely packaged web service. It can also provide a customizable icon in the task bar for shutting down the service if necessary. I think this best meets my needs for the time being.
Please, if you know of any other options, let me know.
Also, you may be wondering, "Why not just write a desktop app?". The simple answer is that I don't need much of a GUI, if any. I need a simple to install web service that can be consumed by various other applications (web, mobile, and desktop included).
Joel seems to think highly of daily builds. For a traditional compiled application I can certainly see his justification, but how does this parallel over to web development -- or does it not?
A bit about the project I'm asking for --
There are 2 developers working on a Django (Python) web app. We have 1 svn repository. Each developer maintains a checkout and thier own copy of MySQL running locally (if you're unfamiliar with Django, it comes bundled with it's own test server, much the way ASP apps can run inside of Visual Studio). Development and testing are done locally, then committed back to the repository. The actual working copy of the website is an SVN checkout (I know about SVN export and it takes too long). The closest we have to a 'build' is a batch file that runs an SVN update on the working copy, does the django bits ('manage.py syncdb'), updates the search engine cache (solr), then restarts apache.
I guess what I don't see is the parallel to web apps.
Are you doing a source controlled web app with 'nightly builds' -- if so, what does that look like?
You can easily run all of your Django unit tests through the Django testing framework as your nightly build.
That's what we do.
We also have some ordinary unit tests that don't leverage Django features, and we run those, also.
Even though Python (and Django) don't require the kind of nightly compile/link/unit test that compiled languages do, you still benefit from the daily discipline of "Don't Break The Build". And a daily cycle of unit testing everything you own is a good thing.
We're in the throes of looking at Python 2.6 (which works perfectly for us) and running our unit tests with the -3 option to see which deprecated features we're using. Having a full suite of unit tests assures us that a change for Python 3 compatibility won't break the build. And running them nightly means that we have to be sure we're refactoring correctly.
Continuous integration is useful if you have the right processes around it. TeamCity from JetBrains is a great starting point if you want to build familiarity:
http://www.jetbrains.com/teamcity/index.html
There's a great article that relates directly to Django here:
http://www.ajaxline.com/continuous-integration-in-django-project
Hope this gets you started.
Web applications built in dynamic languages may not require a "compilation" step, but there can still be a number of "build" steps involved in getting the app to run. Your build scripts might install or upgrade dependencies, perform database migrations, and then run the test suite to insure that the code is "clean" w.r.t. the actual checked-in version in the repository. Or, you might deploy a copy of the code to a test server, then run a set of Selenium integration tests against the new version to insure that core site functionality still works.
It may help to do some reading on the topic of Continuous Integration, which is a very useful practice for webapp dev teams. The more fast-paced and agile your development process, the more you need regular input from automated testing and quality metrics to make sure you fail fast and loud on any broken version of the code.
If it's really just you and one other developer working on it, nightly builds are probably not going to give you much.
I would say that the web app equivalent of nightly builds would be staging sites (which can be built nightly).
Where nightly builds to a staging area start paying real dividends is when you have clients, project managers, and QA people that need to be able to see an up to date, but relatively stable version of the app. Your developer sandboxes (if you're like me, at least) probably spend a lot of time in an unusable state as you're breaking things trying to get the next feature implemented. So the typical problem is that a QA person wants to verify that a bug is fixed, or a PM wants to check that some planned feature was implemented correctly, or a client wants to see that you've made progress on the issue that they care about. If they only have access to developer sandboxes, there's a good chance that when they get around to looking at it, either the sandbox version isn't running (since it means ./manage.py runserver is up in a terminal somewhere) or it's in a broken state because of something else. That really slows down the whole team and wastes a lot of time.
It sounds like you don't have a staging setup since you just automatically update the production version. That could be fine if you're way more careful and disciplined than I (and I think most developers) am and never commit anything that isn't totally bulletproof. Personally, I'd rather make sure that my work has made it through at least some cursory QA by someone other than me before it hits production.
So, in conclusion, the setup where I work:
each developer runs their own sandbox locally (same as you do it)
there's a "common" staging sandbox on a dev server that gets updated nightly from a cronjob. PMs, clients, and QA go there. They are never given direct access to developer sandboxes.
There's an automated (though manually initiated) deployment to production. A developer or the PM can "push" to production when we feel things have been sufficiently QA'd and are stable and safe.
I'd say the only downside (besides a bit of extra overhead setting up the nightly staging builds) is that it makes for a day of turnaround on bug verification. ie, QA reports a bug in the software (based on looking at that day's nightly build), developer fixes bug and commits, then QA must wait until the next day's build to check that the bug is actually fixed. It's usually not that much of a problem since everyone has enough stuff going on that it doesn't affect the schedule. When a milestone is approaching though and we're in a feature-frozen, bugfix only mode, we'll do more frequent manual updates of the staging site.
I've had great success using Hudson for continuous integration. Details on using Hudson with Python by Redsolo.
A few months ago, several articles espousing continuous deployment caused quite a stir online. IMVU has details on how they deploy up to 5 times a day.
The whole idea behind frequent builds (nightly or more frequent like in continuous integration) is to get immediate feedback in order to reduce the elapsed time between the introduction of a problem and its detection. So, building frequently is useful only if you are able to generate some feedback through compilation, (ideally automated) testing, quality checks, etc. Without feedback, there is no real point.