| HTTP verb | Content | URL | Notes | 26 |
|---|---|---|---|
| PUT | file | http://myserver.com/container/newfile | new file | 29 |
| PUT | none | http://myserver.com/container | new container | 32 |
| DELETE | none | http://myserver.com/container/newfile | delete newfile | 35 |
| DELETE | none | http://myserver.com/container | delete container | 38 |
| GET | none | http://myserver.com/ | list containers | 41 |
| GET | none | http://myserver.com/container | list files | 44 |
createBlockBlobFromStream method,
120 | and the Azure SDK does the rest. Now all we need is a curl command to upload a file.
121 |
122 | ```
123 | %curl --data-binary @anyfile.doc --request PUT http://kagemusha.tcowan.c9.io/mycontainer1/anyfile.doc
124 | ```
125 | "anyfile.doc" is assumed to be a file on your system. curl with take that file
126 | and stream it to your Node.js server, which in turn streams the file into Azure
127 | blob storage. If you want to make sure this is happening, visit https://www.myazurestorage.com and use
128 | the tool to browse your azure storage account.
129 |
130 | ####Listing your Containers and Blobs
131 | Before we discuss the listing feature, go ahead and create a few more containers so you'll have something
132 | to list.
133 |
134 | ```
135 | %curl --request PUT http://kagemusha.tcowan.c9.io/mycontainer1
136 | %curl --request PUT http://kagemusha.tcowan.c9.io/mycontainer2
137 | %curl --request PUT http://kagemusha.tcowan.c9.io/mycontainer3
138 | %curl --request PUT http://kagemusha.tcowan.c9.io/mycontainer4
139 |
140 | ```
141 |
142 | So far we've been using PUT to add new things to Azure storage. Listing is a request
143 | to "GET" a list of something, so naturally we'll use an HTTP GET. Here's the code
144 | that lists both containers and blobs:
145 |
146 | ```JavaScript
147 | else if (req.method == 'GET') {
148 | if (containerName == "") {
149 | //list containers
150 | blobService.listContainers(function (error, containers) {
151 | if (error) {
152 | console.log(error);
153 | } else {
154 | containers.forEach(function (container) {
155 | res.write(container.name + '\r\n');
156 | });
157 | }
158 | res.end();
159 | });
160 | } else {
161 | // list blobs
162 | blobService.listBlobs(containerName, function (error, blobs) {
163 | if (error) {
164 | console.log(error);
165 | } else {
166 | blobs.forEach(function (blob) {
167 | res.write(blob.name + " (" + blob.url + ')\r\n');
168 | });
169 | }
170 | res.end();
171 | });
172 | }
173 | ```
174 |
175 | Just as before, we are using the request URL to help us decide what is being requested.
176 | A URL that points to the root of our server will list all containers. A URL that points
177 | to any particular container will list BLOBS within that container. Notice how the BLOBs are listed to
178 | include a url, blob.url. That url points directly to blob storage, bypassing
179 | your Node.js server. While you can stream files from Node, it's important to know that
180 | Azure Storage will stream blobs for you. In cases where you are delivering public images, files, or content it
181 | will be more affordable to use the blobs public URL vs. streaming from your own server. Now lets look
182 | at the curl command to invoke this feature. This is the simplest of all curl commands, a simplet get on a URL.
183 | This command asks our sample Node.js server to list all containers in your azure storage account:
184 |
185 | ```
186 | %curl http://kagemusha.tcowan.c9.io
187 | ```
188 |
189 | To list all BLOBS in container "mycontainer2" use this curl command:
190 |
191 | ```
192 | %curl http://kagemusha.tcowan.c9.io/mycontainer2
193 | ```
194 |
195 | ####Deleting Containers and Blobs
196 | After what we've done till now, this will seem a bit anticlimactic. Delete will obviously
197 | be served by the HTTP verb "DELETE". Essentially we'll be using DELETE instead of PUT against
198 | similar URL strings. To keep the code short and example simple, I've used the
199 | number of path seperated values in the request URL to decide if we're deleting a container or blob:
200 |
201 | ```JavaScript
202 | if (parts.length < 3)
203 | blobService.deleteContainer(containerName, containerDeleted);
204 | else
205 | blobService.deleteBlob(containerName, blobName, blobDeleted);
206 | ```
207 |
208 | And the curl commands (assuming a blob uploaded as "blob1"):
209 |
210 | ```
211 | %curl --request DELETE http://kagemusha.tcowan.c9.io/mycontainer1/blob1
212 | %curl --request DELETE http://kagemusha.tcowan.c9.io/mycontainer1
213 | ```
214 |
--------------------------------------------------------------------------------
/sessions/hour2/02_working-with-filesystem/readme.md:
--------------------------------------------------------------------------------
1 | Working with the Filesystem
2 | ===========================
3 |
4 | In the previous lesson we built out a simple HTTP server that takes requests and
5 | sends back a simple "Hello World!" string:
6 |
7 | ```javascript
8 | var http = require('http');
9 |
10 | function requestCallback(req, res) {
11 | res.writeHead(200, {'Content-Type': 'text/plain'});
12 | res.write('Hello World!');
13 | res.end();
14 | }
15 |
16 | var server = http.createServer(requestCallback);
17 | server.listen(process.env.PORT || 80, "0.0.0.0");
18 | ```
19 |
20 | In this lesson we will do a bit more investigation of the request object, Node's
21 | [filesystem module](http://nodemanual.org/latest/nodejs_ref_guide/fs.html)
22 | and combine the two to send requested files back to the user. Let's start with
23 | the filesystem module.
24 |
25 | ### The Filesystem Module
26 |
27 | There are few points in Node.JS where the asynchronous programming model so
28 | starkly contrasts with convention than with the filesystem module. Why? In most
29 | programming languages, file access means synchronously waiting for the OS to
30 | retrieve the file from disk. In PHP for example if the file read is ongoing
31 | while another visitor requests access to the server, that user must wait for the
32 | read operation to complete.
33 |
34 | Node.JS allows for reading files asynchronously, while other visitors continue
35 | to access the server without delay.
36 |
37 | Consider this simple example, stripped first of HTTP components:
38 |
39 | ```javascript
40 | var fs = require("fs");
41 |
42 | fs.readFile("/etc/hosts", "utf-8", function(err, data) {
43 | if (err)
44 | throw err;
45 | console.log(data);
46 | });
47 |
48 | console.log("FIRST!111!!");
49 | ```
50 |
51 | Let's break this down. First, the filesystem module is loaded with
52 | `var fs = require("fs")`, giving us access to its methods via the `fs` variable.
53 | Next we call the `readFile` method with 3 parameters: the file location, encoding,
54 | and finally a callback function. The 2nd parameter - encoding - is optional; if
55 | it is omitted then the raw buffer data is returned.
56 |
57 | When the file has completely loaded, the 3rd parameter - the callback - is called
58 | with two arguments: `err` (set to null or undefined if no error occurs) and the
59 | `data` from the file.
60 |
61 | Take note of the very last line in this example: `console.log("FIRST!111!!");`.
62 | If you run this code then "FIRST!111!!" will appear _before_ the contents of the
63 | file are spit out. More than demonstrating our fantastic wit with trolling humor,
64 | this drives home our point about the asynchronous model; the event loop continues
65 | on while Node.JS loads up your file.
66 |
67 | ### Sending a Requested File
68 |
69 | Let's build on our HTTP and file knowledge to send requested files back to
70 | visitors.
71 |
72 | ```javascript
73 | var http = require('http');
74 | var fs = require('fs');
75 |
76 | http.createServer(function (req, res) {
77 | fs.readFile(__dirname + req.url, 'utf-8', function(err, data) {
78 | if (err) {
79 | res.writeHead(404, {'Content-Type': 'text/plain'});
80 | res.end('File ' + req.url + ' not found\n');
81 | }
82 | else {
83 | res.writeHead(200, {'Content-Type': 'text/plain'});
84 | res.end(data);
85 | }
86 | });
87 | }).listen(process.env.PORT || 80, "0.0.0.0");
88 | ```
89 |
90 | You can find this code in `server.js` along with this readme.md file. If you
91 | run `server.js` and request "http://[host]/readme.md" the contents of this file
92 | will be returned.
93 |
94 | How does this work? The magic is in `fs.readFile(__dirname + req.url`
95 |
96 | 1. `__dirname` is globally available and set to the directory that the currently
97 | executing script resides in
98 |
99 | 2. `req.url` is set to the path of the URL the user is requesting. If for example
100 | we requested 'http://host/readme.md' then req.url is "/readme.md". If the URL
101 | is only the domain (e.g. "http://nodejs.org") then req.url is "/"
102 |
103 | This code won't work very well if you are requesting non-plaintext files such
104 | as images. In a production file serving environment you would want to set the
105 | Content-Type through a module like [node-mime](https://github.com/bentomas/node-mime).
106 |
107 | ### Caching Files
108 |
109 | While reading files asynchronously is of great benefit to your users, you will
110 | likely want to take advantage of a simple caching method so the code isn't
111 | constantly slamming your disk for the same hilarious cat images.
112 |
113 | ```javascript
114 | var http = require('http');
115 | var fs = require('fs');
116 |
117 | var loadedFiles = {};
118 |
119 | function returnData(res, code, data) {
120 | res.writeHead(code, {'Content-Type': 'text/plain'});
121 | res.end(data);
122 | }
123 |
124 | http.createServer(function (req, res) {
125 | if (loadedFiles[req.url])
126 | return returnData(res, 200, "Cached: " + loadedFiles[req.url]);
127 |
128 | fs.readFile(__dirname + req.url, 'utf-8', function(err, data) {
129 | if (err) {
130 | returnData(res, 404, 'File ' + req.url + ' not found\n');
131 | }
132 | else {
133 | loadedFiles[req.url] = data;
134 | returnData(res, 200, data);
135 | }
136 | });
137 | }).listen(process.env.PORT || 80, "0.0.0.0");
138 | ```
139 |
140 | If the file has been found, it is cached in the loadedFiles object and referenced
141 | by the requested path. Subsequent loads of the same file will be prefixed with
142 | "Cached: " + the file data to demonstrate our cahing technique. Meanwhile we have
143 | abided by the
144 | [DRY principle](http://en.wikipedia.org/wiki/Don't_repeat_yourself) by
145 | consolidating functionality in the `returnData` method.
146 |
147 | ### File Watchers
148 |
149 | Caching is great, but what happens if a cached file has been recently updated?
150 | We don't want to send a stale copy of the file to the client. Luckily for us
151 | Node.JS has [watchers](http://nodemanual.org/latest/nodejs_ref_guide/fs.html#fs.watch).
152 | This means you can set up a watcher on a file or folder and whenever an update
153 | occurs, you get notified.
154 |
155 | Since we are only watching files in this example, we'll use the
156 | [watchFile method](http://nodemanual.org/latest/nodejs_ref_guide/fs.html#fs.watchFile).
157 | The callback takes two
158 | [fs.Stats objects](http://nodemanual.org/latest/nodejs_ref_guide/fs.Stats.html)
159 | as its arguments: `curr` and `prev`
160 |
161 | ```javascript
162 | fs.watchFile('file.html', function (curr, prev) {
163 | console.log('the current modification time is: ' + curr.mtime);
164 | console.log('the previous modification time was: ' + prev.mtime);
165 | });
166 | ```
167 |
168 | Now let's update our sample to include a file watcher on each cached file:
169 |
170 | ```javascript
171 | var http = require('http');
172 | var fs = require('fs');
173 |
174 | var loadedFiles = {};
175 |
176 | function returnData(res, code, data) {
177 | res.writeHead(code, {'Content-Type': 'text/plain'});
178 | res.end(data);
179 | }
180 |
181 | http.createServer(function (req, res) {
182 | var fullPath = __dirname + req.url;
183 |
184 | if (loadedFiles[fullPath])
185 | return returnData(res, 200, "Cached: " + loadedFiles[fullPath]);
186 |
187 | fs.readFile(fullPath, 'utf-8', function(err, data) {
188 | if (err) {
189 | returnData(res, 404, 'File ' + req.url + ' not found\n');
190 | }
191 | else {
192 | // Start watching the file for changes
193 | fs.watchFile(fullPath, function(curr, prev) {
194 | // We only want to know when the "modified" time was updated
195 | if (curr.mtime.getTime() != prev.mtime.getTime()) {
196 | console.log("Cached file [" + fullPath + "] was updated");
197 |
198 | // Read in the file again
199 | fs.readFile(fullPath, 'utf-8', function(err, data) {
200 | if (!err)
201 | loadedFiles[fullPath] = data;
202 | });
203 | }
204 | });
205 |
206 | loadedFiles[fullPath] = data;
207 | returnData(res, 200, data);
208 | }
209 | });
210 | }).listen(process.env.PORT || 80, "0.0.0.0");
211 | ```
212 |
213 | The bulk of our changes start with the comment "//Start watching...". The watcher
214 | callback will fire every time the file is accessed (`curr.atime` is changed) so
215 | we only want to know when the file's content was modified.
216 |
217 | `watchFile` takes an optional 2nd argument `[options]` where you can specify two
218 | properties: `persistent` and `interval`. `persistent` indicates whether the
219 | process should continue to run as long as files are being watched. `interval`
220 | dictates how often the target should be polled, in milliseconds.
221 |
222 | _Fair warning: This technique was for demonstration only and should **not** be used
223 | in a large scale application serving thousands of files. It is quite useful for
224 | other scenarios, however. For ex., imagine you just updated the source for your
225 | application and want to restart the server. A separate node app could watch your
226 | app's `server.js`, see a change was made, then kill and restart the process._
227 |
228 | In the next lesson we will take a step back and look at Node apps from a
229 | conceptual point of view.
--------------------------------------------------------------------------------
/sessions/hour3/01_working-with-a-database/readme.md:
--------------------------------------------------------------------------------
1 | Windows Azure Table Storage
2 | --------
3 | What is Azure Table Storage, and how does one use it from Node. This is paraphrased from https://www.windowsazure.com/en-us/develop/nodejs/how-to-guides/table-services/.
4 |
5 | #### What is Windows Azure Table Storage?
6 |
7 | Azure Table Storage is a NoSQL type of database which can store enormous amounts of data. Data are replicated three times within the same datacenter, and tables are geo-replicated between two datacenters hundreds of miles apart. Tables can be accessed from within Azure, or from a service running elsewhere. It supports a RESTful API for direct access, or one can use a wrapper for access from various environments including Node.
8 |
9 | A single storage account can contain multiple tables. Each table can contain multiple entities. An entity is a set of properties, and can be up to 1 MB. A property is a key-value pair.
10 |
11 | #### What are partition keys and row keys?
12 |
13 | Partition and row keys are part of an entity. Entities with the same partition key are stored together and can be queried quickly. A row key is a unique identifier for each entity. At the very least, an entity will have a PartitionKey, RowKey, and a Timestamp which is added by Azure and can be ignored.
14 |
15 | Quick links to code snippets
16 | --------
17 |
18 | #### How to create an Azure table
19 |
20 | https://gist.github.com/1813187
21 |
22 | #### How to add an entity to a table
23 |
24 | https://gist.github.com/1813271
25 |
26 | #### How to update an entity
27 |
28 | https://gist.github.com/1813285
29 |
30 | #### How to change a group of entities
31 |
32 | https://gist.github.com/1813293
33 |
34 | #### How to query for an entity
35 |
36 | https://gist.github.com/1813302
37 |
38 | #### How to query a set of entities
39 |
40 | https://gist.github.com/1813308
41 |
42 | #### How to query a subset of entity properties
43 |
44 | NB: This won't work in the storage emulator.
45 | https://gist.github.com/1813327
46 |
47 | #### How to delete an entity
48 |
49 | https://gist.github.com/1813337
50 |
51 | #### How to delete a table
52 |
53 | https://gist.github.com/1813345
54 |
55 |
56 | Demo
57 | --------
58 | Let's build a working demo which uses Azure tables. When building a website, you'll probably want to use a proper web framework such as Express, but for our purposes we'll keep things deliberately simple. We'll start with something based on the Hello World example from http://nodejs.org. Note that the arguments inside `listen()` have changed:
59 |
60 | var http = require('http');
61 | http.createServer(function (req, res) {
62 | res.writeHead(200, {'Content-Type': 'text/plain'});
63 | res.end('Hello World\n');
64 | }).listen(port);
65 |
66 | Let's start by importing some modules we'll be using. Add these lines at the top of the file:
67 |
68 | var azure = require('azure');
69 | var formidable = require('formidable'), util = require('util');
70 | var uuid = require('node-uuid');
71 |
72 | `azure` is the Azure SDK, `formidable` is an HTTP forms processing module, `util` contains various utilities, and `node-uuid` will be used to generate UUIDs for the data we'll be putting into Azure Tables.
73 |
74 | Next add this line to set up the application for running either locally, in the Cloud9 IDE, or when deployed on Azure:
75 |
76 | var port = process.env.PORT || 1337; // for C9, Azure, or local.
77 |
78 | Cloud9 and Azure use `process.env.PORT`. If that exists, `port` will be set approriately. Otherwise, port 1337 will be used for running locally.
79 |
80 | Next, add these lines which pertain to Azure:
81 |
82 | var account = azure.ServiceClient.DEVSTORE_STORAGE_ACCOUNT;
83 | var accountKey = azure.ServiceClient.DEVSTORE_STORAGE_ACCESS_KEY;
84 | var tableHost = azure.ServiceClient.DEVSTORE_TABLE_HOST;
85 |
86 | if (process.env.C9_PORT) { // Test if we're running on Cloud9. Change these to your own credentials.
87 | account = 'c9demo';
88 | accountKey = '