http.md


const http = require('http')

http.get('http://courses.cms.caltech.edu/cs11/', res => {
  // `res` is a readable stream, so we can print it
  // by piping it to the standard output
  res.pipe(process.stdout)
})
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>CS 11 Home Page</title>
</head>

...
const server = http.createServer((req, res) => {
  // `req` is the request object; `res` is the response

  // Use the requested URL to serve a file in the `files` directory
  const readStream = fs.createReadStream(path.join('files', req.url))
  readStream.on('error', _ => {
    // Tell the client if the file didn't exist
    res.write('File not found')
    res.end()
  })
  // `res` is a writable stream. Piping the file to it sends it to the client.
  readStream.pipe(res)
})
// Listen for requests on port 80 (the default for HTTP)
server.listen(80)
http.createServer((req, res) => {
  const filePath = path.join('files', req.url)
  if (req.method === 'POST') {
    // A POST request uploads a file.
    // On a POST request, `req` is a readable stream.
    req.pipe(fs.createWriteStream(filePath))
      // Send an empty response when the pipe finishes
      .on('finish', () => res.end())
  }
  else {
    // A GET request retrieves a file
    const readStream = fs.createReadStream(filePath)
    readStream.on('error', _ => {
      res.write('File not found')
      res.end()
    })
    readStream.pipe(res)
  }
}).listen(80)
const filename = process.argv[2]
const uploadName = process.argv[3]

// Make a POST request to the upload URL.
// `request` is a writable stream.
const request = http.request(
  `http://localhost/${uploadName}`,
  {method: 'POST'}
)
// Send the file to upload by piping it into the request stream
fs.createReadStream(filename).pipe(request)
const value = {
  number: 1,
  string: 'abc',
  array: [2, false],
  object: {x: 1, y: 2}
}
const json = JSON.stringify(value)
// '{"number":1,"string":"abc","array":[2,false],"object":{"x":1,"y":2}}'

const value2 = JSON.parse(json)
/*
{
  number: 1,
  string: 'abc',
  array: [2, false],
  object: {x: 1, y: 2}
}
*/
// The last value returned from the generator.
// The initial value is the "seed".
let lastValue = 1

http.createServer((req, res) => {
  if (req.url === '/seed') {
    // POSTing to `/seed` sets the seed of the generator
    let body = ''
    req.setEncoding('utf8')
      .on('data', chunk => {
        // Concatenate request body into a single string
        body += chunk
      })
      .on('end', () => {
        // Parse the JSON request body and extract the seed
        lastValue = JSON.parse(body).seed
        // Send an empty response
        res.end()
      })
  }
  else {
    // GETing `/next` updates the generator
    // and responds with the new value
    lastValue = (lastValue * A) % M
    res.write(JSON.stringify({value: lastValue}))
    res.end()
  }
}).listen(80)
const count = Number(process.argv[2])

// Seed the generator with the current time (in milliseconds)
const seedRequest =
  http.request('http://localhost/seed', {method: 'POST'}, _ => {
    // Then obtain `count` random numbers
    getNumbers()
  })
seedRequest.write(JSON.stringify({seed: Date.now()}))
seedRequest.end()

function getNumbers() {
  for (let i = 0; i < count; i++) {
    http.get('http://localhost/next', res => {
      let body = ''
      res.setEncoding('utf8')
        .on('data', chunk => {
          // Concatenate response body into a single string
          body += chunk
        })
        .on('end', () => {
          // Parse the JSON response and print the number
          console.log(JSON.parse(body).value)
        })
    })
  }
}
const http = require('http')
const https = require('https')

// Request with HTTP -> redirects to HTTPS
http.get('http://www.apple.com', res => {
  // 301 (Moved Permanently)
  console.log(res.statusCode)
  // Location: https://www.apple.com/
  console.log(res.headers.location)
})

// Request with HTTPS -> successful
https.get('https://www.apple.com', res => {
  res.pipe(process.stdout)
})
// Make a POST request to the given URL,
// using the given JSON string as the body
fetch('http://localhost/seed', {
  method: 'POST',
  body: JSON.stringify({seed: Date.now()})
})
  .then(res => {
    const promises = []
    // Get 100 random numbers
    for (let i = 0; i < 100; i++) {
      promises.push(
        // Make a GET request to the given URL
        fetch('http://localhost/next')
          // Parse the response from JSON
          .then(res => res.json())
      )
    }
    // Wait for all 100 responses
    return Promise.all(promises)
  })
  .then(numbers => {
    // Extract the value from each JSON response
    // and print it to the console
    for (const number of numbers) console.log(number.value)
  })
http.createServer((req, res) => {
  if (req.url === '/') {
    // Redirect `/` to `/index.html`
    res.statusCode = 301
    res.setHeader('Location', '/index.html')
    res.end() // don't send any response
    return
  }

  // By default, `res.statusCode` is 200 OK
  const readStream = fs.createReadStream(path.join('files', req.url))
  readStream.on('error', _ => {
    // Indicate the file didn't exist with a 404
    res.statusCode = 404
    res.write('File not found')
    res.end()
  })
  readStream.pipe(res)
})
Date: Mon, 30 Mar 2020 03:23:17 GMT
Expires: -1
Cache-Control: private, max-age=0
Content-Type: text/html; charset=ISO-8859-1
Set-Cookie: 1P_JAR=2020-03-30-03; expires=Wed, 29-Apr-2020 03:23:17 GMT; path=/; domain=.google.com; Secure
Set-Cookie: NID=201=ap24VohKW7_KXQXVaGGgxgusYR1fqqFqi2YfovchUYmgz4O4aK-O_4zBIKE1xy98W_oIF_9RsVMEIFv7wIhr71w-VVwlTKNReWxmM9c-5XuPPiVYOxShgEwEFzy5O4_V2JzhB9ax3gPno38QYICdA6TBcaPjVMm77qdVeWpjkzk; expires=Tue, 29-Sep-2020 03:23:17 GMT; path=/; domain=.google.com; HttpOnly
// The map of usernames to their passwords.
// Don't ever store raw passwords in a real application!
const passwords = new Map()
  .set('alice', '123456')
  .set('bob', 'supersecretpassword')

http.createServer((req, res) => {
  // Check the provided `user` and `password` headers
  const password = passwords.get(req.headers.user)
  if (password === undefined || password !== req.headers.password) {
    res.statusCode = 403 // Forbidden
    res.end()
    return
  }

  // If the login is valid, send the file
  const readStream = fs.createReadStream(path.join('files', req.url))
  readStream.on('error', _ => {
    res.write('File not found')
    res.end()
  })
  readStream.pipe(res)
}).listen(80)
http.get(
  'http://localhost/index.html',
  {headers: {user: 'bob', password: 'supersecretpassword'}},
  res => {
    // If allowed to access the page, print it out
    if (res.statusCode === 200) res.pipe(process.stdout)
    else console.error('Invalid login')
  }
)