Skip to content
This repository
Browse code

[doc refactor] Continue work editing and refactoring content files fo…

…r blacksmith-based rendering
  • Loading branch information...
commit 670f9ab75f676357eba4801d7550ab7110b1b243 1 parent 13a5127
Charlie Robbins authored November 27, 2012
20  content/articles/a-quickstart/faq.md
Source Rendered
... ...
@@ -1,7 +1,6 @@
1  
-# Frequently Asked Questions
2  
-<a name='faq'></a>
3  
-
  1
+<hr>
4 2
 **For more information about pricing, see [the pricing FAQ](http://nodejitsu.com/paas/faq.html).**
  3
+<hr>
5 4
 
6 5
 ## "How do I reset my password?"
7 6
 
@@ -11,20 +10,24 @@ One way is to use jitsu. Simply type:
11 10
 
12 11
 where `:username` is your username. Alternately, go to <http://develop.nodejitsu.com/> and click the "forgot password" link, where you will be prompted for your username. Either process will send you an email with further instructions.
13 12
 
  13
+<hr>
14 14
 ## "Is there a cheatsheet somewhere?"
15 15
 
16 16
 There sure is! Check out <http://cheatsheet.nodejitsu.com>.
17 17
 
  18
+<hr>
18 19
 ## "How are programs kept alive? Do I need to use Forever?"
19 20
 
20 21
 Nodejitsu's cloud services watch your programs for you! You shouldn't have to do anything special to keep your apps running, much less use Forever.
21 22
 
  23
+<hr>
22 24
 ## "How can I make my app use a port other than port 80?"
23 25
 
24 26
 Connecting to other servers using arbitrary ports requires no special considerations. However, *listening* for outside connections is currently limited to port 80 on the Nodejitsu platform because we require http host headers for domain name resolution of subdomains. Consequentially, each subdomain may only host one listening service.
25 27
 
26 28
 The ability to host TCP applications on nodejitsu and listen on non-80 ports is on our roadmap but has no associated timeline.
27 29
 
  30
+<hr>
28 31
 ## "How do I make Koding work with jitsu?"
29 32
 
30 33
 By default, Koding will not install packages globally, due to a permission error. You can fix this by setting the
@@ -36,16 +39,17 @@ And then you can install jitsu normally:
36 39
 
37 40
 `npm i jitsu -g`
38 41
 
  42
+<hr>
39 43
 ## "Can I use jitsu with Cloud9 IDE (<http://c9.io>)?"
40 44
 
41 45
 Yes! Follow these steps to install jitsu.
42 46
 
43 47
 1. Install the latest npm globally: `npm install -g npm`
44  
-
45 48
 2. Install the latest jitsu locally: `npm install jitsu`
46 49
 
47 50
 Now you can use jitsu as usual. If you get error, try `npm rm -g jitsu && npm cache clean`.
48 51
 
  52
+<hr>
49 53
 ## "How can I turn off the require-analyzer in jitsu? I want to manage my own dependencies!"
50 54
 
51 55
 There are three ways to disable the require-analyzer:
@@ -54,24 +58,30 @@ There are three ways to disable the require-analyzer:
54 58
 * Add `"analyze": false` to your package.json to disable it on a per-app basis.
55 59
 * Set "analyze" to `false` in your `~/.jitsuconf` to disable it on a global level.
56 60
 
  61
+<hr>
57 62
 ## "How Do I add my GitHub repository as a dependency?"
58 63
 
59 64
 Use the following format: `https://github.com/:user/:repo/tarball/:branch`
60 65
 
  66
+<hr>
61 67
 ## "Why won't this C++ addon compile?"
62 68
 
63 69
 Many [C++ addons](http://nodejs.org/docs/latest/api/addons.html) require libraries that are not included in Nodejitsu's infrastructure by default. For example, [node-canvas](https://github.com/learnboost/node-canvas) requires [cairo](http://cairographics.org/). Nodejitsu has cairo and many other such libraries, but may not have some more obscure ones.
64 70
 
  71
+<hr>
65 72
 ## "How do I specify which files not to bundle? How do I know what files are getting bundled?"
66 73
 
67  
-Jitsu uses npm to bundle files, meaning that jitsu bundles files in exactly the same manner than npm bundles published modules. You can read about this in [npm's documentation](http://npmjs.org/doc/developers.html).
  74
+`jitsu` uses npm to bundle files, meaning that jitsu bundles files in exactly the same manner than npm bundles published modules. You can read about this in [npm's documentation](http://npmjs.org/doc/developers.html).
68 75
 
69 76
 In more detail: npm uses a file called `.npmignore`, which should contain a list of files and folders to ignore for the purpose of bundling. If this file does not exist, npm will use git's ignore file, called `.gitignore`, instead. This means that, if you want to bundle files that are ignored by git, you should create an `.npmignore` even if it's blank.
70 77
 
71 78
 Finally, jitsu has the ability to bundle your app without deploying with the `jitsu package create` command. You can use this to make sure that the resulting .tgz file is as you expect.
72 79
 
  80
+<hr>
73 81
 ## "How do I fix `Error: package.json error: can't find starting script`?"
74 82
 
75 83
 Nodejitsu requires a starting script in the package.json to know which script to run to start your application. You need to make sure that the scripts.start field in your package.json points to the correct starting script.
76 84
 
77 85
 A common issue is using "node app" as the value of scripts.start in your package.json. This won't work on Nodejitsu because the file extension is not specified. You'll need to do something along the lines of "node app.js".
  86
+
  87
+[meta:title]: <> (FAQ)
128  content/articles/a-quickstart/hello-world.md
Source Rendered
... ...
@@ -1,101 +1,75 @@
1  
-# Hello World: A Tutorial
2  
-<a name="hiworld"></a>
3  
-
4  
-In this tutorial, you will write a simple "hello world" web application in
5  
-Node.js, and then deploy it using jitsu, Nodejitsu's command line interface.
6  
-
7  
-Before you get started, you should have 
8  
-[node.js](https://github.com/joyent/node/wiki) installed. If you are using 
9  
-a node.js version older than v0.6.0 (not recommended) you will also need to 
10  
-separately install 
11  
-[Node Package Manager](https://github.com/isaacs/npm/#readme) (npm).
  1
+In this tutorial, you will write a simple "hello world" web application in Node.js, and then deploy it using jitsu, Nodejitsu's command line interface. Before you get started, you should have [node.js](https://github.com/joyent/node/wiki) installed. 
12 2
 
  3
+<hr>
13 4
 ## Write A Server
14 5
 
15  
-Let's start with a very basic Node.js http server. Create a folder called
16  
-`myapp/` and then create a file inside the folder called `server.js`. Inside
17  
-this file, write the following code:
  6
+Let's start with a very basic Node.js http server. Create a folder called `myapp/` and then create a file inside the folder called `server.js`. Inside this file, write the following code:
18 7
 
19  
-
20  
-    // requires node's http module
21  
-    var http = require('http');
22  
-        
23  
-    // creates a new httpServer instance
24  
-    http.createServer(function (req, res) {
25  
-      // this is the callback, or request handler for the httpServer
26  
-      
27  
-      // respond to the browser, write some headers so the 
28  
-      // browser knows what type of content we are sending
29  
-      res.writeHead(200, {'Content-Type': 'text/html'});
30  
-           
31  
-      // write some content to the browser that your user will see
32  
-      res.write('<h1>hello, i know nodejitsu.</h1>');
  8
+``` js
  9
+  // requires node's http module
  10
+  var http = require('http');
33 11
       
34  
-      // close the response
35  
-      res.end();
36  
-    }).listen(8080); // the server will listen on port 8080
37  
-
38  
-
39  
-
40  
-That's all the code you'll need for starters. Save your server and get ready to
41  
-deploy!
42  
-
43  
-## Deploy with Jitsu
44  
-
45  
-In this tutorial, we will use [jitsu](http://github.com/nodejitsu/jitsu) to deploy
46  
-our "hello world" application. Jitsu is a
47  
-[Command Line Interface](http://en.wikipedia.org/wiki/Command-line_interface)
48  
-for using Nodejitsu's platform. We've designed jitsu to be
49  
-suitable for command line beginners, but still be powerful and extensible
50  
-enough for production usage. If you aren't a fan of the command line or don't
51  
-have terminal access you can still do app deployments through the
52  
-[Nodejitsu Web Application](https://webops.nodejitsu.com/).
53  
-
54  
-If this is your first time deploying an application and you are eager to get
55  
-started, we recommend using jitsu: it has a one line installer, it's
56  
-self-documenting, and with it you'll be able to deploy your app in seconds.
57  
-Plus, it's what's in the tutorial.
58  
-
59  
-## Installation
  12
+  // creates a new httpServer instance
  13
+  http.createServer(function (req, res) {
  14
+    // this is the callback, or request handler for the httpServer
  15
+    
  16
+    // respond to the browser, write some headers so the 
  17
+    // browser knows what type of content we are sending
  18
+    res.writeHead(200, {'Content-Type': 'text/html'});
  19
+         
  20
+    // write some content to the browser that your user will see
  21
+    res.write('<h1>hello, i know nodejitsu.</h1>');
  22
+    
  23
+    // close the response
  24
+    res.end();
  25
+  }).listen(8080); // the server will listen on port 8080
  26
+```
  27
+
  28
+That's all the code you'll need for starters. Save your server and get ready todeploy!
  29
+
  30
+<hr>
  31
+## Deploy with `jitsu`
  32
+
  33
+In this tutorial, we will use [jitsu](http://github.com/nodejitsu/jitsu) to deploy our "hello world" application. `jitsu` is a
  34
+[Command Line Interface](http://en.wikipedia.org/wiki/Command-line_interface) for using Nodejitsu's platform. We've designed jitsu to be suitable for command line beginners, but still be powerful and extensible enough for production usage.
  35
+
  36
+If this is your first time deploying an application and you are eager to get started, we recommend using jitsu: it has a one line installer, it's self-documenting, and with it you'll be able to deploy your app in seconds. Plus, it's what's in the tutorial.
  37
+
  38
+### Installation
60 39
 
61 40
 In order to install jitsu, open a terminal and type:
62 41
 
63  
-     [sudo] npm install jitsu -g
  42
+```
  43
+  [sudo] npm install jitsu -g
  44
+````
64 45
 
65  
-This command will install jitsu on your system; the `-g` makes npm install it
66  
-globally, rather than as a local module.
  46
+This command will install jitsu on your system; the `-g` makes npm install it globally, rather than as a local module.
67 47
 
68 48
 ![](https://github.com/nodejitsu/jitsu/raw/master/assets/jitsu.png)
69 49
 
70  
-After installation, run the `jitsu` command from your command line. Since it's
71  
-your first time using jitsu, you will be prompted to log in with an existing
72  
-account or to create a new account.
  50
+After installation, run the `jitsu` command from your command line. Since it's your first time using jitsu, you will be prompted to log in with an existing account or to create a new account.
73 51
 
74 52
 ![](https://github.com/nodejitsu/jitsu/raw/master/assets/login.png)
75 53
 
76 54
 **Once you've logged in, you can deploy your app immediately.**
77 55
 
78  
-## One Line Deployment
  56
+### One Line Deployment
79 57
 
80 58
 Open a terminal:
81 59
 
82  
-    cd /home/me/myapp
83  
-    jitsu deploy
84  
-
85  
-This will create a new application snapshot, generate and/or update project
86  
-metadata, and deploy the project in the current path to
87  
-[Nodejitsu](http://nodejitsu.com). If it's your first deployment, you'll be
88  
-prompted for some information such as *<u>your app's name</u>*, its 
89  
-*<u>nodejitsu subdomain</u>*, and its *<u>start script</u>*. It's really easy and we promise it will 
90  
-only take a few seconds.
91  
-
  60
+``` 
  61
+  cd /home/me/myapp
  62
+  jitsu deploy
  63
+```
92 64
 
93  
-    prompt: subdomain (myapp): myapp
94  
-    prompt: scripts.start (server.js): 
95  
-    prompt: version (0.0.0): 
  65
+This will create a new application snapshot, generate and/or update project metadata, and deploy the project in the current path to [Nodejitsu](http://nodejitsu.com). If it's your first deployment, you'll be prompted for some information such as *<u>your app's name</u>*, its  *<u>nodejitsu subdomain</u>*, and its *<u>start script</u>*. It's really easy and we promise it will  only take a few seconds.
96 66
 
  67
+```
  68
+  prompt: subdomain (myapp): myapp
  69
+  prompt: scripts.start (server.js): 
  70
+  prompt: version (0.0.0): 
  71
+``` 
97 72
 
98  
-Now just open up your favorite browser, and go to
99  
-`myapp.nodejitsu.com`. If everything has been set up correctly, then
100  
-you, too, are on the path of nodejitsu!
  73
+Now just open up your favorite browser, and go to `myapp.nodejitsu.com`. If everything has been set up correctly, then you too, are on the path of nodejitsu!
101 74
 
  75
+[meta:title]: <> (Hello World: A Tutorial)
2  content/articles/a-quickstart/index.md
Source Rendered
... ...
@@ -0,0 +1,2 @@
  1
+
  2
+[meta:title]: <> (Quickstart)
7  content/articles/api/index.md
Source Rendered
... ...
@@ -1,6 +1,3 @@
1  
-# JSON API
2  
-<a name='api'></a>
3  
-
4 1
 Nodejitsu provides a web API for developers who want to interact with the Nodejitsu platform programatically. This API is built to be [RESTful](http://en.wikipedia.org/wiki/Representational_State_Transfer) and communicates via [JSON]. The API is the most low-level way of interacting with the Nodejitsu platform. For most deployment scenarios you should use our command line tool, [jitsu], the [online administrative interface][webops], or use our [WebHook API][webhooks] when integrating with third party services.
5 2
 
6 3
 ## API Clients
@@ -184,4 +181,6 @@ Nodejitsu provides integrated logging solutions for your applications. Your logs
184 181
 [webops]: https://webops.jit.su
185 182
 [webhooks]: https://webhooks.nodejitsu.com
186 183
 [nodejitsu]: http://nodejitsu.com
187  
-[curl]: http://curl.haxx.se/
  184
+[curl]: http://curl.haxx.se/
  185
+
  186
+[meta:title]: <> (JSON API)
76  content/articles/appendix/haibu.md
Source Rendered
... ...
@@ -1,55 +1,47 @@
1  
-# Create Your Own Cloud With Haibu
2  
-<a name='haibu'></a>
3  
-
4  
-Haibu is an open-source tool for spawning and managing several node.js
5  
-applications on a single server. It's an integral part of Nodejitsu's
6  
-production stack and is fully supported by a dedicated team of core node.js
7  
-developers.
8  
-
9  
-By installing haibu, a user creates a development environment for themselves
10  
-that mirrors the functionality of Nodejitsu's cloud platform! Any project that
11  
-can be deployed on Nodejitsu can be ran by haibu.
12  
-
13  
-Haibu, which is Japanese for "hive", wraps node.js applications in a "carapace"
14  
-and converts them into managed "drones". This approach allows haibu to directly
15  
-interact with node.js applications and add all sorts of additional
16  
-functionality. Haibu also contains a plugin system, so you can easily add even
17  
-more functionality.
18  
-
19  
-Haibu builds on this concept of "drones" and exposes a robust and granular API
20  
-for interacting with your node.js applications. At a low level, haibu's API is
21  
-exposed as a RESTFul HTTP webservice. Any system that supports basic HTTP
22  
-requests can communicate with a haibu server. If you are working in Node.js,
23  
-haibu comes with a high-level Node.js API client.
  1
+Haibu is an open-source tool for spawning and managing several node.js applications on a single server. It's an integral part of Nodejitsu's production stack and is fully supported by a dedicated team of core node.js developers.
24 2
 
  3
+By installing haibu, a user creates a development environment for themselves that mirrors the functionality of Nodejitsu's cloud platform! Any project that can be deployed on Nodejitsu can be ran by haibu.
  4
+
  5
+Haibu, which is Japanese for "hive", wraps node.js applications in a "carapace" and converts them into managed "drones". This approach allows haibu to directly interact with node.js applications and add all sorts of additional functionality. Haibu also contains a plugin system, so you can easily add even more functionality.
  6
+
  7
+Haibu builds on this concept of "drones" and exposes a robust and granular API for interacting with your node.js applications. At a low level, haibu's API is exposed as a RESTFul HTTP webservice. Any system that supports basic HTTP requests can communicate with a haibu server. If you are working in Node.js, haibu comes with a high-level Node.js API client.
  8
+
  9
+<hr>
25 10
 ## Installation
26 11
 
27  
-    [sudo] npm install haibu -g
  12
+```
  13
+  [sudo] npm install haibu -g
  14
+```
28 15
 
29 16
 This will install haibu globally. You can also grab the source [directly from git](https://github.com/nodejitsu/haibu).
30 17
 
  18
+<hr>
31 19
 ## Usage
32 20
 
33 21
 To start haibu, all you have to do is run `haibu`:
34 22
 
35  
-    $ haibu 
36  
-          __                  __               
37  
-         / /_    ______  __  / /_     __  __   
38  
-        / __ \  / __  / / / /  __ \  / / / /   
39  
-       / / / / / /_/ / / / /  /_/ / / /_/ /    
40  
-      /_/ /_/  \__,_/ /_/ /_/\___/  \__,_/     
41  
-      
42  
-      This is Open Source Software available under
43  
-      the MIT License.
44  
-      
45  
-      © 2010 Nodejitsu Inc.
46  
-      All Rights Reserved - www.nodejitsu.com
47  
-      haibu started @ 10.0.1.4 on port 9002 as api-server
48  
-        using plugins: config, exceptions, directories, log, http
49  
-
50  
-Haibu is an http server that exposes a REST api on port 9002. You can either
51  
-access this API client with a regular HTTP client, or use our [haibu-api](https://github.com/nodejitsu/haibu-api/tree/master/node.js) module. Unfortunately, jitsu does not work with haibu's HTTP API, only the nodejitsu API.
52  
-
  23
+```
  24
+  $ haibu 
  25
+        __                  __               
  26
+       / /_    ______  __  / /_     __  __   
  27
+      / __ \  / __  / / / /  __ \  / / / /   
  28
+     / / / / / /_/ / / / /  /_/ / / /_/ /    
  29
+    /_/ /_/  \__,_/ /_/ /_/\___/  \__,_/     
  30
+  
  31
+    This is Open Source Software available under
  32
+    the MIT License.
  33
+  
  34
+    © 2010 Nodejitsu Inc.
  35
+    All Rights Reserved - www.nodejitsu.com
  36
+    haibu started @ 10.0.1.4 on port 9002 as api-server
  37
+      using plugins: config, exceptions, directories, log, http
  38
+```
  39
+
  40
+Haibu is an http server that exposes a REST api on port 9002. You can either access this API client with a regular HTTP client, or use our [haibu-api](https://github.com/nodejitsu/haibu-api/tree/master/node.js) module. Unfortunately, jitsu does not work with haibu's HTTP API, only the nodejitsu API.
  41
+
  42
+<hr>
53 43
 ## Additional Documentation
54 44
 
55 45
 For more documentation, visit haibu's [github page](https://github.com/nodejitsu/haibu).
  46
+
  47
+[meta:title]: <> (Run it yourself With Haibu)
2  content/articles/appendix/index.md
Source Rendered
... ...
@@ -0,0 +1,2 @@
  1
+
  2
+[meta:title]: <> (Appendix)
7  content/articles/appendix/open-source.md
Source Rendered
... ...
@@ -1,6 +1,4 @@
1  
-# Open Source Projects
2  
-<a name='opensource'></a>
3  
-
  1
+<hr>
4 2
 ## Why Open Source
5 3
 
6 4
 Most of Nodejitsu's technology stack is released as open source software. We
@@ -10,6 +8,7 @@ developers to review and improve our software. We've already received invaluable
10 8
 contributions to our platform from developers who would have never seen our code
11 9
 if we had not open-sourced it.
12 10
 
  11
+<hr>
13 12
 ## Where To Find Our Projects
14 13
 
15 14
 Nodejitsu hosts its open-source projects on [Github](https://github.com):
@@ -25,6 +24,7 @@ github, and if you want to create an account it's free. You will need a
25 24
 [git client](http://git-scm.com/download) if you wish to clone any of our
26 25
 code repositories.
27 26
 
  27
+<hr>
28 28
 ## How To Contribute
29 29
 
30 30
 Anyone can contribute to any of our open-source projects at any time.
@@ -32,3 +32,4 @@ Our [github site](https://github.com/nodejitsu) has the facilities for managing
32 32
 patches, issues, code comments, version control, and just about anything else an
33 33
 open source developer could need.
34 34
 
  35
+[meta:title]: <> (Open Source Projects)
57  content/articles/appendix/package.json.md → content/articles/appendix/package-json.md
Source Rendered
... ...
@@ -1,50 +1,54 @@
1  
-# Appendix: package.json
2  
-<a name='apx:package'></a>
3  
-
  1
+<hr>
4 2
 **[package.json.jit.su](http://package.json.jit.su) is an interactive package.json properties explorer! Highly recommended.**
  3
+<hr>
5 4
 
6 5
 ## Understanding the package.json format
7 6
 A package.json file describes your application, its dependencies, and other various application metadata. For a detailed spec on creating a package.json you can check out Isaac's fine documentation [here](https://github.com/isaacs/npm/blob/master/doc/developers.md#readme). 
8 7
 
  8
+<hr>
9 9
 ## Preparing a package.json for your application
10 10
 
11 11
 Nodejitsu requires that you create a valid [package.json](#package_json) for your application. The package.json will determine certain important pieces of information about your application which are required for deployment. Since sometimes it can get confusing when constructing your package.json file, we provide wizards in our CLI tool and on our website for creating one. 
12 12
 
13 13
 Here is an example of what your package.json might look like:
14 14
 
15  
-
16  
-    {
17  
-      "name": "hellonode",
18  
-      "subdomain": "hellonode",
19  
-      "scripts": {
20  
-        "start": "node server.js"
21  
-      },
22  
-      "version": "0.0.0"
23  
-    }
  15
+``` js
  16
+  {
  17
+    "name": "hellonode",
  18
+    "subdomain": "hellonode",
  19
+    "scripts": {
  20
+      "start": "node server.js"
  21
+    },
  22
+    "version": "0.0.0"
  23
+  }
  24
+```
24 25
 
25 26
 Notice the "scripts" property? This is where you'll store information about specific scripts in your application. The "start" property indicates the script that will get called when your application is started. Usage is compatible with `npm start`.
26 27
 
  28
+<hr>
27 29
 ## Specifying dependencies in your package.json
28 30
 
29 31
 If your application requires additional dependencies or third-party libraries, Nodejitsu fully supports npm module dependency resolution. All you have to do is list your dependencies the exact same way you would if you were packaging a module for npm. Here is an example of the same package.json with a few dependencies.
30 32
 
31  
-
32  
-    {
33  
-      "name": "hellonode",
34  
-      "subdomain": "hellonode",
35  
-      "scripts": {
36  
-        "start": "server.js"
37  
-      },
38  
-      "dependencies": {
39  
-        "async": "0.1.x",
40  
-        "colors": "0.5.x",
41  
-        "request": "1.9.x"
42  
-      },
43  
-      "version": "0.0.0"
44  
-    }
  33
+``` js
  34
+  {
  35
+    "name": "hellonode",
  36
+    "subdomain": "hellonode",
  37
+    "scripts": {
  38
+      "start": "server.js"
  39
+    },
  40
+    "dependencies": {
  41
+      "async": "0.1.x",
  42
+      "colors": "0.5.x",
  43
+      "request": "1.9.x"
  44
+    },
  45
+    "version": "0.0.0"
  46
+  }
  47
+````
45 48
 
46 49
 Your dependencies will be resolved when your application deploys to Nodejitsu.
47 50
 
  51
+<hr>
48 52
 ## Nodejitsu-Specific package.json Properties
49 53
 
50 54
 A few package.json properties have special behavior on the Nodejitsu platform:
@@ -55,3 +59,4 @@ A few package.json properties have special behavior on the Nodejitsu platform:
55 59
 * *scripts.start*: This field is also used for `npm start`. However, nodejitsu's current implementation takes a path, whereas npm's implementation takes a shell command.
56 60
 * *analyze*: Set this to "false" to force jitsu to not analyze for the app's dependencies.
57 61
 
  62
+[meta:title]: <> (Understanding package.json)
5  content/articles/appendix/resources.md
Source Rendered
... ...
@@ -1,6 +1,3 @@
1  
-# Appendix: Resources
2  
-<a name='apx:resources'></a>
3  
-
4 1
 New to Node.js? **Don't be scared!**  There are plenty of resources out there
5 2
 for beginners.  Here are just a few:
6 3
 
@@ -19,3 +16,5 @@ already solve your problem.
19 16
 - <http://cheatsheet.jit.su> is a nodejitsu cheatsheet listing the most common commands.
20 17
 - <http://package.json.jit.su> is an interactive reference for the package.json format.
21 18
 - <http://blog.nodejitsu.com/npm-cheatsheet> is a quick cheatsheet for npm commands.
  19
+
  20
+[meta:title]: <> (More Resources)
191  content/articles/a-quickstart/features.md → content/articles/features/index.md
Source Rendered
... ...
@@ -1,115 +1,110 @@
1  
-# Features of the Nodejitsu Platform
2  
-<a name='features'></a>
3  
-
4  
-The Nodejitsu platform makes writing and deploying web applications a snap!
5  
-In addition to simple yet powerful tools for deployment, the Nodejitsu platform
6  
-also has snapshot management, database hosting and connectivity, and more!
  1
+The Nodejitsu platform makes writing and deploying web applications a snap! In addition to simple yet powerful tools for deployment, the Nodejitsu platform also has snapshot management, database hosting and connectivity, and more!
7 2
 
8 3
 There are three main tools for deploying and managing applications to Nodejitsu:
9 4
 
10  
-* [Jitsu](#jitsu), The Nodejitsu command line tool 
11  
-* The Nodejitsu [Web Application](#web_admin), An easy to use web interface for
12  
-managing your applications
  5
+* [`jitsu`](#jitsu), the Nodejitsu command line tool 
  6
+* The Webops [Web Application](#web_admin), an easy to use web interface for managing your applications
13 7
 * Nodejitsu's JSON [API](#json_api)
14 8
 
15 9
 Each of these tools allow developers to access the same functionality.
16 10
 
  11
+<hr>
  12
+
  13
+* [Application Scalability with Drones](#feature/drones)
  14
+* [Zero-downtime Deploys](#feature/zero-downtime)
  15
+* [Multi-Version Node Support](#feature/multi-node)
  16
+* [Versioning with Snapshots](#feature/snapshots)
  17
+* [Databases](#feature/databases)
  18
+* [Environment Variables](#feature/envvars)
  19
+* [Piggy-back SSL](#feature/ssl)
  20
+* [Custom Domains](#feature/custom-domains)
  21
+
  22
+<hr>
  23
+<a name="feature/drones"></a>
17 24
 ## Application Scalability with Drones
18 25
 
19 26
 Each deployed application runs as a [drone](https://github.com/nodejitsu/haibu-carapace) on a [haibu](https://github.com/nodejitsu/haibu) application server. Because of this architecture, one app can be served by *any amount of drones on arbitrary machines*, giving you many options for scaling your application.
20 27
 
  28
+<hr>
  29
+<a name="feature/zero-downtime"></a>
21 30
 ## Zero Downtime Deploys
22 31
 
23 32
 When deploying a new application, nodejitsu keeps hosting your old app version until the new deploy is confirmed to be running. This means your applications never go down, even if you have a bad deploy.
24 33
 
  34
+<hr>
  35
+<a name="feature/multi-node"></a>
25 36
 ## Multi-Version Node Support
26 37
 
27  
-Nodejitsu allows users to choose which version of node they want their
28  
-application to run on. In order to set your node version, specify it in your 
29  
-`package.json`'s "engines" field. For example:
30  
-
31  
-
32  
-    {
33  
-      "author": "Nodejitsu <josh@nodejitsu.com>",
34  
-      "version": "0.1.0",
35  
-      "scripts": {
36  
-        "start": "node bin/server"
37  
-      },
38  
-      "analyze": false,
39  
-      "name": "helloworld",
40  
-      "engines": {
41  
-        "node": "v0.6.x"
42  
-      }
  38
+Nodejitsu allows users to choose which version of node they want their application to run on. In order to set your node version, specify it in your  `package.json`'s "engines" field. For example:
  39
+
  40
+``` js
  41
+  {
  42
+    "author": "Nodejitsu <josh@nodejitsu.com>",
  43
+    "version": "0.1.0",
  44
+    "scripts": {
  45
+      "start": "node bin/server"
  46
+    },
  47
+    "analyze": false,
  48
+    "name": "helloworld",
  49
+    "engines": {
  50
+      "node": "v0.6.x"
43 51
     }
44  
-
  52
+  }
  53
+```
45 54
 
46 55
 If no node engine is specified, jitsu will prompt for it automatically. Currently Nodejitsu runs node `0.6.x` and `0.8.x`.
47 56
 
  57
+<hr>
  58
+<a name="feature/snapshots"></a>
48 59
 ## Snapshots
49  
-<a name='features/snapshots'></a>
50 60
 
51  
-Every time you deploy to Nodejitsu, we automatically take a
52  
-[snapshot](http://en.wikipedia.org/wiki/Snapshot_\(computer_storage\)) of your
53  
-application. Using any of our tools, you can view and manage snapshots, or even
54  
-roll back to an old snapshot when disaster strikes in your production 
55  
-environment. *During a deploy, nodejitsu will create a new snapshot automatically.*
  61
+Every time you deploy to Nodejitsu, we automatically take a [snapshot](http://en.wikipedia.org/wiki/Snapshot_\(computer_storage\)) of your application. Using any of our tools, you can view and manage snapshots, or even roll back to an old snapshot when disaster strikes in your production environment. *During a deploy, nodejitsu will create a new snapshot automatically.*
56 62
 
57  
-Jitsu commands for snapshot management include:
  63
+`jitsu` commands for snapshot management include:
58 64
 
59 65
 * `jitsu snapshots list <app-name>` will list all snapshots for an application.
60 66
 * `jitsu snapshots activate <app-name>` allows you to choose which snapshot your drones are running.
61 67
 * `jitsu snapshots fetch <app-name>` will download a specified snapshot of your application to your computer.
62 68
 
63  
-## Databases
  69
+<hr>
64 70
 <a name='features/databases'></a>
  71
+## Databases
65 72
 
66  
-Applications on Nodejitsu are ready to be connected to any database. If you
67  
-already have a database running, Nodejitsu can connect to your pre-existing
68  
-database. If you require a new database, Nodejitsu can provide you *free*
69  
-instances of several different types of databases. These free instances are
70  
-great for development purposes or hobby sites. If you require a high traffic
71  
-or production database we provide an easy upgrade path to industrial strength
72  
-database hosting.
  73
+Applications on Nodejitsu are ready to be connected to any database. If you already have a database running, Nodejitsu can connect to your pre-existing database. If you require a new database, Nodejitsu can provide you *free* instances of several different types of databases. These free instances are great for development purposes or hobby sites. If you require a high traffic or production database we provide an easy upgrade path to industrial strength database hosting.
73 74
 
74 75
 ### Creating new Databases
75 76
 
76  
-If you require database hosting you can create a new database instance of any
77  
-of our supported databases using [jitsu](#jitsu) or Nodejitsu's [API](#api).
78  
-Cloud database hosting is currently provided by 
79  
-[IrisCouch](http://www.iriscouch.com), [RedisToGo](http://redistogo.com) 
80  
-and [MongoLab](https://www.mongolab.com).
  77
+If you require database hosting you can create a new database instance of any of our supported databases using [jitsu](#jitsu) or Nodejitsu's [API](#api). Cloud database hosting is currently provided by [IrisCouch](http://www.iriscouch.com), [RedisToGo](http://redistogo.com) and [MongoLab](https://www.mongolab.com).
81 78
 
82 79
 ### Existing Databases
83 80
 
84  
-If you already have an externally hosted Database, Nodejitsu is capable of
85  
-connecting to it. We've got Database hosting if you need it, but we fully
86  
-support externally hosted Databases.
  81
+If you already have an externally hosted Database, Nodejitsu is capable of connecting to it. We've got Database hosting if you need it, but we fully support externally hosted Databases.
87 82
 
88 83
 ### Connecting Applications to Databases
89 84
 
90  
-Whenever you create a database using Nodejitsu, you will be provided with all
91  
-the information you need to connect to your database.
  85
+Whenever you create a database using Nodejitsu, you will be provided with all the information you need to connect to your database.
92 86
 
93 87
 #### CouchDB
94 88
 
95  
-If you run `jitsu databases create couchdb myCouch`, jitsu will tell you the
96  
-url for your new couchdb from iriscouch:
97  
-
98  
-    info:    Welcome to Nodejitsu user
99  
-    info:    It worked if it ends with Nodejitsu ok
100  
-    info:    Executing command databases create couchdb myCouch
101  
-    info:    Database myCouch was created.
102  
-    data:    Database Type: couch
103  
-    data:    Database Name: myCouch
104  
-    data:    Connection url: http://subdomain.iriscouch.com:5984
105  
-    data:    SSL connection url: https://subdomain.iriscouch.com:6984
106  
-    info:    Nodejitsu ok
  89
+If you run `jitsu databases create couchdb myCouch`, jitsu will tell you the url for your new CouchDB from IrisCouch:
107 90
 
108  
-You can connect to this database using any http client, or a couchdb specific
109  
-library. For example, you can connect with curl:
  91
+```
  92
+  info:    Welcome to Nodejitsu user
  93
+  info:    It worked if it ends with Nodejitsu ok
  94
+  info:    Executing command databases create couchdb myCouch
  95
+  info:    Database myCouch was created.
  96
+  data:    Database Type: couch
  97
+  data:    Database Name: myCouch
  98
+  data:    Connection url: http://subdomain.iriscouch.com:5984
  99
+  data:    SSL connection url: https://subdomain.iriscouch.com:6984
  100
+  info:    Nodejitsu ok
  101
+```
110 102
 
  103
+You can connect to this database using any http client, or a CouchDB specific library. For example, you can connect with curl:
111 104
 
112  
-    $ curl http://subdomain.iriscouch.com:5984
  105
+``` bash
  106
+  $ curl http://subdomain.iriscouch.com:5984
  107
+```
113 108
 
114 109
 Or, you can connect with [nano](https://github.com/dscape/nano):
115 110
 
@@ -117,7 +112,6 @@ Or, you can connect with [nano](https://github.com/dscape/nano):
117 112
 
118 113
 You can also access your database in your browser by going to http://subdomain.iriscouch.com:5984/_utils .
119 114
 
120  
-
121 115
 #### MongoDB
122 116
 
123 117
 If you run `jitsu databases create mongo myMongo`, jitsu 
@@ -198,6 +192,8 @@ platform. Passing `{ parser: 'javascript' }` to `redis.createClient` will ensure
198 192
 usage of the javascript parser. Check out the other possible options in the 
199 193
 [node redis docs](https://github.com/mranney/node_redis#rediscreateclientport-host-options).
200 194
 
  195
+<hr>
  196
+<a name="feature/envvars"></a>
201 197
 ## Environment Variable Management
202 198
 
203 199
 Nodejitsu allows users to modify the environment variables exposed to their 
@@ -207,40 +203,32 @@ it is necessary restart your app for it to take effect.
207 203
 Available commands are `list`, `get`, `set`, `delete`, and 
208 204
 `clear`. 
209 205
 
210  
-`jitsu env list` will list any and all environment variables in an apps 
211  
-current working directory (Note: the app needs to have been deployed before the 
212  
-environment variables can be accessed).  
213  
-`jitsu env list <myapp>` will list any and all environment variables related 
214  
-to `<myapp>` in an account.  
215  
-`jitsu env get <key>` will display the apps key environment variable 
216  
-`<value>`.  
217  
-`jitsu env set <key> <value>` will set the apps `<key>` environment variable 
218  
-to `<value>`.  
219  
-`jitsu env delete <key>` will delete the apps `<key>` environment variable.  
220  
-`jitsu env clear` will delete all of the apps environment variables after a 
221  
-prompt.
  206
+* `jitsu env list` will list any and all environment variables in an apps current working directory (Note: the app needs to have been deployed before the environment variables can be accessed).  
  207
+* `jitsu env list <myapp>` will list any and all environment variables related  to `<myapp>` in an account.  
  208
+* `jitsu env get <key>` will display the apps key environment variable `<value>`.  
  209
+* `jitsu env set <key> <value>` will set the apps `<key>` environment variable to `<value>`.
  210
+* `jitsu env delete <key>` will delete the apps `<key>` environment variable.  
  211
+* `jitsu env clear` will delete all of the apps environment variables after a prompt.
222 212
 
223 213
 An Example:
224 214
 
225  
-    $ jitsu env set NODE_ENV production
226  
-
  215
+```
  216
+  $ jitsu env set NODE_ENV production
  217
+```
227 218
 
228  
-This will set the environment variable $NODE_ENV to have the string value 
229  
-"production". Remember, this will not take effect until the app is started 
230  
-again (`jitsu apps start` -- there is no need to take your app down with a 
231  
-`restart` with the zero downtime deploys).
  219
+This will set the environment variable $NODE_ENV to have the string value  "production". Remember, this will not take effect until the app is started again (`jitsu apps start` -- there is no need to take your app down with a `restart` with the zero downtime deploys).
232 220
 
233  
-## SSL on nodejitsu.com subdomains
  221
+<hr>
  222
+<a name="feature/ssl"></a>
  223
+## Piggyback SSL nodejitsu.com, jitsu.com and jit.su
234 224
 
235 225
 Our balancers can proxy https to http, so you get SSL on nodejitsu.com subdomains automatically! For example, the app behind [http://nodejitsu.com](http://nodejitsu.com) is serving http, but visiting [https://nodejitsu.com](https://nodejitsu.com) works without any special action on our part.
236 226
 
237  
-Please note that this only works with `nodejitsu.com` (not `jitsu.com` or `jit.su`) at this time.
238  
-
239  
-If you need to identify if you are receiving http or https traffic use the 
240  
-`x-forwarded-proto` response header value, see 
241  
-[headers.jit.su](http://headers.jit.su/) for more information on headers 
242  
-passed through the balancers.
  227
+If you need to identify if you are receiving http or https traffic use the `x-forwarded-proto` response header value, see 
  228
+[headers.jit.su](http://headers.jit.su/) for more information on headers passed through the balancers.
243 229
 
  230
+<hr>
  231
+<a name="feature/custom-domains"></a>
244 232
 ## Custom Domains
245 233
 
246 234
 We allow users to host their applications on custom domains by specifying their
@@ -253,21 +241,4 @@ Our balancers use [SNI](https://en.wikipedia.org/wiki/Server_Name_Indication) wh
253 241
 
254 242
 *Note: This feature is not exposed through our API or other tools at this time. If you need this feature, please contact support at `support@nodejitsu.com`.*
255 243
 
256  
-## Addons
257  
-
258  
-*Note: Coming soon!*
259  
-
260  
-Addons add functionality to your apps by extending and adding features to
261  
-Nodejitsu's platform and integrating third party services. For instance,
262  
-one of our addons provides powerful [Mailchimp](http://mailchimp.com)-based
263  
-mailing list management.
264  
-
265  
-## Marketplace
266  
-
267  
-*Note: Coming soon!*
268  
-
269  
-The Marketplace is an online store where you can browse ready to deploy
270  
-Node.js Applications. The Marketplace is a great place to start if you are new
271  
-to Node.js development or want to share your existing Node.js Application with
272  
-the world.
273  
-
  244
+[meta:title]: <> (Platform Features)
133  content/articles/features/jitsu.md
Source Rendered
... ...
@@ -0,0 +1,133 @@
  1
+<hr>
  2
+[`jitsu`](http://github.com/nodejitsu/jitsu) is a [Command Line Interface](http://en.wikipedia.org/wiki/Command-line_interface) (CLI) for interacting with the Nodejitsu platform. It's open-source and easy to use.
  3
+<hr>
  4
+
  5
+## Installation
  6
+
  7
+`jitsu` is distributed using the Node Package Manager (npm). Installing jitsu with npm is as simple as a single command:
  8
+
  9
+```
  10
+  [sudo] npm install -g jitsu
  11
+```
  12
+
  13
+This command installs jitsu to your Node path, so that it may be run like any other global shell command.
  14
+
  15
+<hr>
  16
+## Usage
  17
+
  18
+Commands for jitsu follow this pattern:
  19
+
  20
+```
  21
+  jitsu <resource> <action> <param1> <param2> ...
  22
+```
  23
+
  24
+For example, in `jitsu apps deploy`, "apps" is the resource and "deploy" is the action.
  25
+
  26
+<hr>
  27
+### jitsu deploy (jitsu apps deploy)
  28
+
  29
+`jitsu deploy` will attempt to deploy the application in the current directory to [Nodejitsu](http://nodejitsu.com). It deploys your application using the following steps:
  30
+
  31
+1. Creates the application (if necessary)
  32
+2. Creates or validates the package.json
  33
+3. Packages and creates a new snapshot
  34
+4. Starts the application
  35
+
  36
+If you had a previous deployment running, and the most recent deploy failed, your old  application will contnue to run without interruption.
  37
+
  38
+<hr>
  39
+### jitsu list (jitsu apps list)
  40
+
  41
+`jitsu list` lists your applications, as well as their respective states, subdomains, entry points and latest snapshots.
  42
+
  43
+<hr>
  44
+### jitsu help <resource> <action>
  45
+
  46
+**_`jitsu` is self-documenting_** All commands will yield friendly messages to you if you specify incorrect parameters. Additionally, `jitsu help` will return useful help messages about any given resource or resource/action pair. for instance:
  47
+
  48
+```
  49
+  $ jitsu help apps deploy
  50
+  info:   Welcome to Nodejitsu
  51
+  info:   It worked if it ends with Nodejitsu ok
  52
+  info:   Executing command help apps deploy
  53
+  help:   
  54
+  help:   
  55
+  help:   Deploys an application using the following steps:
  56
+  help:   
  57
+  help:     1. Creates the application (if necessary)
  58
+  help:     2. Creates or validates the package.json
  59
+  help:     3. Packages and creates a new snapshot
  60
+  help:     4. Stops the application (if neccessary)
  61
+  help:     5. Starts the application
  62
+  help:   
  63
+  help:   jitsu deploy
  64
+  help:   jitsu apps deploy
  65
+  help:   
  66
+  info:   Nodejitsu ok
  67
+```
  68
+
  69
+If no resource and/or action are specified, then `jitsu help` alone will describe what resources are available.
  70
+
  71
+<hr>
  72
+### jitsu apps <action>
  73
+
  74
+In addition to the commands aliased to `jitsu create`, `jitsu deploy` and  `jitsu list`, the `apps` resource allows you to create, destroy, stop, start and otherwise interact with your applications.
  75
+
  76
+If your app is in a stopped state, you will not be charged for it, ever. To put your app in a stopped state run `jitsu apps stop <appname>`.
  77
+
  78
+<hr>
  79
+### jitsu env <action>
  80
+
  81
+`jitsu` allows you to set environment variables on your production environment. For example, [Express](http://expressjs.com), a popular node.js web framework, uses the `NODE_ENV` environment variable to change behavior based on whether the environment is for development or production. In the case of Express, nodejitsu has `NODE_ENV` set to "production" by default, but if one wanted to change this variable or add more for their application, `jitsu env` supplies the tools to do so.
  82
+
  83
+<hr>
  84
+### jitsu config <action>
  85
+
  86
+`jitsu config` commands allow you to edit your local jitsu configuration file.
  87
+
  88
+<hr>
  89
+### jitsu snapshots <action>
  90
+
  91
+`jitsu snapshots *` commands allow you to work with snapshots for your  Applications on Nodejitsu. Snapshots are images of your Application's code that are deployed to the Nodejitsu Platform.
  92
+
  93
+For commands that take a `<name>` parameter, if no parameter is supplied, `jitsu` will attempt to read the package.json from the current directory.
  94
+
  95
+<hr>
  96
+### jitsu users <action>
  97
+
  98
+`jitsu users *` commands allow you to work with new or existing Nodejitsu user accounts. You will be prompted for additional user information as required.
  99
+
  100
+<hr>
  101
+### jitsu install
  102
+
  103
+`jitsu install` is a built-in tool for downloading "starter apps" to speed up development. For example, here's how to use `jitsu install` to download a "hello world" application:
  104
+
  105
+```
  106
+  $ jitsu install helloworld
  107
+  info:   Welcome to Nodejitsu jesusabdullah
  108
+  info:   It worked if it ends with Nodejitsu ok
  109
+  info:   Executing command install helloworld
  110
+  info:   Installing helloworld locally.
  111
+  warn:   Downloading packages from npm, this may take a moment...
  112
+  info:   helloworld installed.
  113
+  help:   You can now jitsu deploy this application
  114
+  prompt: Would you like to start this application locally? (yes): no
  115
+  info:   Nodejitsu ok
  116
+  $ cd helloworld
  117
+  $ ls
  118
+  bin  node_modules  package.json  ReadMe.md
  119
+```
  120
+
  121
+<hr>
  122
+## Configuring jitsu
  123
+
  124
+All user-level configuration data for your local jitsu install is located in the *.jitsuconf* file located in your home directory. Directly modifying this file is not advised. You should be able to make all configuration changes using `jitsu config`.
  125
+
  126
+### Selected Properties of .jitsuconf
  127
+
  128
+* *loglength*: Change this to modify the default length of returned logs from `jitsu logs`.
  129
+* *loglevel*: Change this to modify the logging levels displayed by jitsu. Defaults to "info".
  130
+* *colors*: Change this to false to turn off jitsu's colors. Defaults to `true`.
  131
+* *analyze*: Change this to false to disable require-analyzer for all apps. Defaults to `true`.
  132
+
  133
+[meta:title]: <> (Using the jitsu CLI)
6  content/articles/api/webhooks.md → content/articles/features/webhooks.md
Source Rendered
... ...
@@ -1,5 +1,3 @@
1  
-# Nodejitsu Web-hook API
2  
-
3 1
 Access the `Admin` section on your open source node.js Github repository. Click `Service Hooks` and then `Nodejitsu`. You will be presented with a form with four fields:
4 2
 
5 3
 * Username, which defaults to your Github username
@@ -499,4 +497,6 @@ Bottom line if you want to do deployments for private repositories do not specif
499 497
     <td>401</td>
500 498
     <td>We tried to authenticate with github but it failed</td>
501 499
   </tr>
502  
-</table>
  500
+</table>
  501
+
  502
+[meta:title]: <> (Continuous Deployment)
7  content/articles/features/webops.md
Source Rendered
... ...
@@ -0,0 +1,7 @@
  1
+<hr>
  2
+The Nodejitsu Web Application allows developers to administrate their applications through a web interface. This interface allows access to the same deployment functionality that can be found in [jitsu](#jitsu) or the [JSON API](#api). 
  3
+
  4
+The web admin interface may be found at <https://webops.nodejitsu.com>.
  5
+<hr>
  6
+
  7
+[meta:title]: <> (Using Webops)
142  content/articles/jitsu/index.md
Source Rendered
... ...
@@ -1,142 +0,0 @@
1  
-# The Jitsu Client
2  
-<a name='jitsu'></a>
3  
-
4  
-[Jitsu](http://github.com/nodejitsu/jitsu) is a
5  
-[Command Line Interface](http://en.wikipedia.org/wiki/Command-line_interface)
6  
-(CLI) for interacting with the Nodejitsu platform. It's open-source and easy
7  
-to use.
8  
-
9  
-## Installation
10  
-
11  
-Jitsu is distributed using the Node Package Manager (npm). Installing jitsu
12  
-with npm is as simple as a single command:
13  
-
14  
-     [sudo] npm install -g jitsu
15  
-
16  
-This command installs jitsu to your Node path, so that it may be run like any other global shell command.
17  
-
18  
-## Usage
19  
-
20  
-Commands for jitsu follow this pattern:
21  
-
22  
-    jitsu <resource> <action> <param1> <param2> ...
23  
-
24  
-For example, in `jitsu apps deploy`, "apps" is the resource and "deploy" is the
25  
-action.
26  
-
27  
-### jitsu deploy (jitsu apps deploy)
28  
-
29  
-`jitsu deploy` will attempt to deploy the application in the current directory
30  
-to [Nodejitsu](http://nodejitsu.com). It deploys your application using the
31  
-following steps:
32  
-
33  
-1. Creates the application (if necessary)
34  
-2. Creates or validates the package.json
35  
-3. Packages and creates a new snapshot
36  
-4. Starts the application
37  
-
38  
-If you had a previous deployment running, and the most recent deploy failed, your old 
39  
-application will contnue to run without interruption
40  
-
41  
-### jitsu list (jitsu apps list)
42  
-
43  
-`jitsu list` lists your applications, as well as their respective states,
44  
-subdomains, entry points and latest snapshots.
45  
-
46  
-### jitsu help <resource> <action>
47  
-
48  
-*Jitsu is self-documenting.*
49  
-All commands will yield friendly messages to you if you specify incorrect
50  
-parameters. Additionally, `jitsu help` will return useful help messages about
51  
-any given resource or resource/action pair. for instance:
52  
-
53  
-    josh@pidgey:~$ jitsu help apps deploy
54  
-    info:   Welcome to Nodejitsu
55  
-    info:   It worked if it ends with Nodejitsu ok
56  
-    info:   Executing command help apps deploy
57  
-    help:   
58  
-    help:   
59  
-    help:   Deploys an application using the following steps:
60  
-    help:   
61  
-    help:     1. Creates the application (if necessary)
62  
-    help:     2. Creates or validates the package.json
63  
-    help:     3. Packages and creates a new snapshot
64  
-    help:     4. Stops the application (if neccessary)
65  
-    help:     5. Starts the application
66  
-    help:   
67  
-    help:   jitsu deploy
68  
-    help:   jitsu apps deploy
69  
-    help:   
70  
-    info:   Nodejitsu ok
71  
-    josh@pidgey:~$ 
72  
-
73  
-If no resource and/or action are specified, then `jitsu help` alone will
74  
-describe what resources are available.
75  
-
76  
-### jitsu apps <action>
77  
-
78  
-In addition to the commands aliased to `jitsu create`, `jitsu deploy` and 
79  
-`jitsu list`, the `apps` resource allows you to create, destroy, stop, start and
80  
-otherwise interact with your applications.
81  
-
82  
-If your app is in a stopped state, you will not be charged for it, ever. To put your
83  
-app in a stopped state run `jitsu apps stop <appname>`.
84  
-
85  
-### jitsu env <action>
86  
-
87  
-Jitsu allows you to set environment variables on your production environment.
88  
-For example, [Express](http://expressjs.com), a popular node.js web framework,
89  
-uses the `NODE_ENV` environment variable to change behavior based on whether the
90  
-environment is for development or production. In the case of Express, nodejitsu
91  
-has `NODE_ENV` set to "production" by default, but if one wanted to change this
92  
-variable or add more for their application, `jitsu env` supplies the tools to
93  
-do so.
94  
-
95  
-### jitsu config <action>
96  
-
97  
-`jitsu config` commands allow you to edit your local jitsu configuration file.
98  
-
99  
-### jitsu snapshots <action>
100  
-
101  
-`jitsu snapshots *` commands allow you to work with snapshots for your 
102  
-Applications on Nodejitsu. Snapshots are images of your Application's code that
103  
-are deployed to the Nodejitsu Platform.
104  
-
105  
-For commands that take a `<name>` parameter, if no parameter is supplied,
106  
-jitsu will attempt to read the package.json from the current directory.
107  
-
108  
-### jitsu users <action>
109  
-
110  
-`jitsu users *` commands allow you to work with new or existing Nodejitsu user
111  
-accounts. You will be prompted for additional user information as required.
112  
-
113  
-
114  
-### jitsu install
115  
-
116  
-`jitsu install` is a built-in tool for downloading "starter apps" to speed up development. For example, here's how to use `jitsu install` to download a "hello world" application:
117  
-
118  
-    josh@onix:/tmp$ jitsu install helloworld
119  
-    info:   Welcome to Nodejitsu jesusabdullah
120  
-    info:   It worked if it ends with Nodejitsu ok
121  
-    info:   Executing command install helloworld
122  
-    info:   Installing helloworld locally.
123  
-    warn:   Downloading packages from npm, this may take a moment...
124  
-    info:   helloworld installed.
125  
-    help:   You can now jitsu deploy this application
126  
-    prompt: Would you like to start this application locally? (yes): no
127  
-    info:   Nodejitsu ok
128  
-    josh@onix:/tmp$ cd helloworld
129  
-    josh@onix:/tmp/helloworld$ ls
130  
-    bin  node_modules  package.json  ReadMe.md
131  
-
132  
-
133  
-## Configuring jitsu
134  
-
135  
-All user-level configuration data for your local jitsu install is located in the *.jitsuconf* file located in your home directory. Directly modifying this file is not advised. You should be able to make all configuration changes using `jitsu config`.
136  
-
137  
-### Selected Properties of .jitsuconf
138  
-
139  
-* *loglength*: Change this to modify the default length of returned logs from `jitsu logs`.
140  
-* *loglevel*: Change this to modify the logging levels displayed by jitsu. Defaults to "info".
141  
-* *colors*: Change this to false to turn off jitsu's colors. Defaults to `true`.
142  
-* *analyze*: Change this to false to disable require-analyzer for all apps. Defaults to `true`.
38  content/articles/support.md
Source Rendered
... ...
@@ -1,41 +1,31 @@
1  
-# Support
2  
-<a name='support'></a>
3  
-
4  
-Nodejitsu has a team of developers standing by to assist users with any issues
5  
-they may come across while deploying and administrating their web applications
6  
-on the Nodejitsu platform. Nodejitsu strives to have a lightning-fast
7  
-turnaround on all issues you may have!
  1
+Nodejitsu has a team of developers standing by to assist users with any issues they may come across while deploying and administrating their web applications on the Nodejitsu platform. Nodejitsu strives to have a lightning-fast turnaround on all issues you may have!
8 2
 
9 3
 The following can be extremely helpful for the support team if you have them ahead of time:
10 4
 
11 5
 1. username/appname.
12  
-1. A [gist](https://gist.github.com/) of your package.json file.
13  
-1. A [gist](https://gist.github.com/) of your command/action and error output.
14  
-1. Versions of tools and apps; `jitsu -v`, `node -v`, `npm -v`.
15  
-1. The platform you are working on--Linux, Mac, Windows, etc.
  6
+2. A [gist](https://gist.github.com/) of your package.json file.
  7
+3. A [gist](https://gist.github.com/) of your command/action and error output.