2016년 12월 12일 월요일

socketcluster tutorial - 11. 성능 (Performance)

성능


벤치 마크


처리량 (SocketCluster v0.9.8)


이 테스트의 목적은 SocketCluster가 적절한 머신에서 얼마나 많은 JavaScript (JSON) 객체를 처리할 수 있는지를 보는 것이었습니다.

절차

이 CPU 벤치 마크에서 SocketCluster는 Linux를 실행하는 8 코어 Amazon EC2 m3.2xlarge 인스턴스에서 테스트하였습니다.

  • 100 명의 동시 클라이언트가 있을 때까지 매 초마다 새로운 클라이언트를 생성하였습니다.
  • 전송한 최대 메시지 수는 170k (클라이언트 당 초당 1700 개의 메시지)로 설정하였습니다.
  • 메시지는 완전히 양방향이었습니다 - 클라이언트는 JSON으로 캐스팅 된 JavaScript 객체를 포함하는 'ping'이벤트를 보내고 서버는 'pong'JavaScript 객체로 응답합니다. 이 객체에는 현재 워커가 지금까지 받은 총 ping의 수를 나타내는 'count'속성이 있습니다.
  • SocketCluster는 5 개의 로드 밸런서, 5 명의 워커 및 2 명의 브로커를 사용하도록 설정하였습니다.

관측



  • 로드 밸런서 모듈을 v0.9.12로 업그레이드하면 워커 간에 훨씬 더 균등한 분배가 이루어졌습니다. 이전 버전의 loadbalancer는 갑작스러운 트래픽 급증에도 반응이 없었습니다. 새로운 버전의 loadbalancer는 무작위 확률을 결정론적 '불운'보정으로 활용하는 알고리즘을 사용하여 부하가 워커 간에 균등하게 분산되도록 합니다.
  • 프로세스 설정은 이전 벤치 마크에서 제대로 조정되지 않았습니다. CPU 코어보다 많은 프로세스를 사용하는 것은 낭비입니다.
  • 더 적은 수의 프로세스를 사용하여 매우 양호한 부하로 평균 3.33을 만들었습니다 (가능한 8 개 중). 아마도 우리의 현재 설정으로 20만 개의 접속이 되도록 했을 것입니다. 로드 밸런서 5대, 워커 5개, 브로커 2개가 여전히 이상적이진 않습니다. 아마도 한 명의 워커 프로세스가 완벽한 균형을 이루었을 것입니다.

스크린샷



동시성 (SocketCluster v0.9.20)


이 테스트의 목적은 SocketCluster가 얼마나 많은 동시 사용자를 처리할 수 ​​있는지 추정하는 것이었습니다.

절차


SocketCluster는 Linux를 실행하는 8 코어 Amazon EC2 m3.2xlarge 인스턴스에 배포되었습니다. SocketCluster 클라이언트는 Linux를 실행하는 최대 32 코어 Amazon EC2 c3.8xlarge 인스턴스에서 실행되었습니다. 이것은 단일 시스템에서 42K 동시 사용자를 시뮬레이트 할 수 있도록 하기 위해 필요했습니다.

  • 가상 사용자 (클라이언트)는 초당 약 160의 속도로 생성 (연결)되었습니다.
  • 동시 가상 사용자의 최대 수는 42K로 설정되었습니다. 이는 서버가 아닌 클라이언트의 한계입니다.
  • 각 가상 사용자는 평균 6 초마다 'ping'메시지를 보냈습니다. 'ping'이벤트의 페이로드는 JSON으로 변환한 JavaScript 객체였으며 응답은 지금까지 현재 워커가 받은 총 Ping의 수를 포함하는 'pong'객체였습니다.
  • 표준 브라우저 (Chrome)가 SC 서버에 원격으로 연결되어 (때때로 ping을 보내서) 전체 테스트에서 서비스가 실제 성능을 발휘하는지 확인합니다. 또한 시간이 지남에 따라 증가하는 ping 수를 확인하는 데 사용되었습니다.
  • SocketCluster는 4 개의 로드 밸런서, 3 명의 워커 및 1 개의 브로커를 실행하도록 설정하였습니다.

관측


  • CPU(가장 바쁜 워커)는 끝에 거의 60%까지 최고조에 달했고 새로운 연결은 여전히 ​​생성되었습니다 (초당 160 회).
  • 42K로 연결이 완료되면 가장 바쁜 워커의 CPU 사용이 약 45 %
  • 브로커는 많은 작업을 하지 않았습니다. 실제로 7 개의 CPU 코어만 완전히 활용되었습니다.
  • 로드 평균은 2 점 미만 (가능한 8 점)이었으므로 더 많은 사용자를 확보할 여지가 충분했습니다.
  • 메모리 사용량은 CPU 사용량과 비교할 때 무시할 정도였습니다.
  • huge 32-core EC2 클라이언트 시스템은 42K 연결을 훨씬 넘어서지 못했습니다. 클라이언트의 CPU 사용량은 모든 32 코어에서 100 %에 가까워졌습니다. 특정 지점을 지나면 클라이언트는 지연되기 시작하고 서버의 부하가 감소합니다.

스크린샷


socketcluster tutorial - 6. 미들웨어 및 인증 (Middleware and authorization)

미들웨어 및 인증


SocketCluster를 사용하면 클라이언트는 JavaScript를 사용하여 특정 채널로 데이터를 청취하고 발행하여 메시지를 서로 공유할 수 있습니다. 기본적으로 누구나 자신이 좋아하는 채널에 데이터에 수신하고 게시할 수 있습니다. 일부 시스템에서는 이것이 문제가 되지 않지만 대부분의 시스템은 사용자가 서로 상호 작용할 수 있는 방법을 규제하기 위해 어느 정도의 접근 제어가 필요합니다. 대부분의 시스템은 적절한 접근 권한을 시행하기 위해 연결을 인증하고 권한을 부여하는 방법이 필요합니다. 미들웨어 기능은 이러한 모든 작업을 수행할 수 있는 깔끔한 중앙 집중식 방식을 제공합니다.

SocketCluster에서 모든 실시간 이벤트는 서버에서 처리하기 전에 미들웨어 기능을 통과해야 합니다. SocketCluster는 다양한 종류의 상호 작용을 처리할 수 있는 다양한 종류의 미들웨어 라인을 제공합니다. 가장 유용한 미들웨어 라인은 워커 프로세스에 있지만 로드 밸런서(HTTP 용)에 의해 노출되는 미들웨어 라인이 있습니다. 이 튜토리얼에선 워커(실시간) 미들웨어에만 초점을 맞춥니다.

워커는 실시간 scServer 객체를 통해 미들웨어를 노출합니다. 이 객체는 worker.getSCServer()를 사용하여 액세스 할 수 있습니다.

미들웨어 기능을 서버에 추가하려면 다음을 사용해야 합니다.
scServer.addMiddleware (middlewareType, middlewareFunction);
scServer에서 사용할 수있는 미들웨어 유형은 다음과 같습니다.
scServer.MIDDLEWARE_HANDSHAKE
scServer.MIDDLEWARE_SUBSCRIBE
scServer.MIDDLEWARE_PUBLISH_IN
scServer.MIDDLEWARE_PUBLISH_OUT
scServer.MIDDLEWARE_EMIT
middlewareFunction에 전달한 req인자는 사용한 미들웨어의 종류에 따라 다릅니다. 다음 예제의 err객체는 JavaScript의 Error객체를 상속한 사용자 정의 클래스를 기반으로 합니다. 서버에서 스택 트레이스를 사용하지 않는 경우 폼에서 {name: 'MyCustomError', message: 'This is a custom error'} (또는 추가 사용자 정의 속성을 사용하여)와 같은 일반 객체를 next(err)에게 전달할 수 있습니다. 다음은 각 종류의 미들웨어를 사용하는 방법을 보여주는 몇 가지 샘플 코드 스니펫입니다.

핸드쉐이크

// WebSocket 핸드쉐이크용
wsServer.addMiddleware(wsServer.MIDDLEWARE_HANDSHAKE,
  function (req, next) {
    // ...
    if (...) {
      next() // Allow
    } else {
      var err = new MyCustomHandshakeFailedError('Handshake failed');
      next(err); // Block
      // next(true); // 서버 측에서 경고하지 않고 조용히 next() 블록에 true를 전달합니다.
    }
  }
);

구독하기

기본 인증 토큰 만료 오류로 실패합니다.
// Error 객체에 사용자 정의 속성을 가질 수 있습니다.
// 서버 측에서 경고를하지 않고 조용히 next () 블록에 true를 전달합니다.
wsServer.addMiddleware(wsServer.MIDDLEWARE_SUBSCRIBE,
  function (req, next) {
    // ...
    if (req.authTokenExpiredError) {
      next(req.authTokenExpiredError); // 기본 인증 토큰 기간 만료 오류로 실패
    } else if (...) {
      next() // Allow
    } else {
      var socketId = req.socket.id;
      var err = new MyCustomSubscribeFailedError(socketId + ' cannot subscribe to channel ' + req.channel);
      // You can have custom properties on your Error object.
      err.code = 1234;
      next(err); // Block
      // next(true); // 서버 측에서 경고하지 않고 조용히 next() 블록에 true를 전달합니다.
    }
  }
);

발행

SC는 게시를 위해 두 가지 미들웨어 라인을 지원합니다. MIDDLEWARE_PUBLISH_IN은 게시한 메시지를 처리한 후 (개별 소켓으로 보내기 직전) MIDDLEWARE_PUBLISH_OUT가 캡처한 메시지를 처리하는 동안 브로커에 도달하기 전에 서버에 도달할 때 인바운드 메시지를 캡처합니다. MIDDLEWARE_PUBLISH_OUT을 사용하면 메시지가 특정 소켓에 도달하는 것을 차단할 수 있습니다. 이 경우에는 메시지를 게시한 소켓이 자신의 메시지를 받지 않도록 메시지와 미들웨어를 설계할 수 있습니다.

Publish In

wsServer.addMiddleware(wsServer.MIDDLEWARE_PUBLISH_IN,
  function (req, next) {
    // ...
    if (...) {
      next() // Allow
    } else {
      var err = MyCustomPublishInFailedError(req.socket.id + ' cannot publish channel ' + req.channel);
      next(err); // Block
      // next(true); // 서버 측에서 경고하지 않고 조용히 next() 블록에 true를 전달합니다.
    }
  }
);

Publish out

wsServer.addMiddleware(wsServer.MIDDLEWARE_PUBLISH_OUT,
  function (req, next) {
    // ...
    if (...) {
      next() // Allow
    } else {
      var err = MyCustomPublishOutFailedError('Blocked publishing message out to ' + req.socket.id);
      next(err); // Block with notice
      // next(true); // 서버 측에서 경고하지 않고 조용히 next() 블록에 true를 전달합니다.
    }
  }
);

전송하기

wsServer.addMiddleware(wsServer.MIDDLEWARE_EMIT,
  function (req, next) {
    // ...
    if (...) {
      next() // Allow
    } else {
      var err = MyCustomEmitFailedError(req.socket.id + ' is not allowed to emit event ' + req.event);
      next(err); // Block
      // next(true); // 서버 측에서 경고하지 않고 조용히 next() 블록에 true를 전달합니다.
    }
  }
);
next() 함수는 언제든지 (비동기가 좋습니다) 호출할 수 있지만, 결과적으로 호출하는 것을 확인해야 합니다. 그렇지 않으면 클라이언트의 subscribe/ publish/emit 액션이 단순 타임아웃이나 클라이언트 쪽에서 원인을 알 수 없는 타임아웃 오류를 발생할 것입니다. 클라이언트가 뭔가를 하지 못하도록 차단하려면 명시적 오류를 주는 것이 더욱 다루기 쉽습니다.

socketcluster tutorial - 10. 복수 호스트 확장 (Scaling across multiple hosts)

복수 호스트 확장


SocketCluster를 사용하면 수직적(시스템/호스트의 여러 CPU 코어에 걸쳐)으로 수평적으로(여러 호스트에 걸쳐) 확장할 수 있습니다. 수평으로 확장하려면 SCC(권장)를 사용하거나 처음부터 직접 솔루션을 구현할 수 있습니다. SCC를 사용하는 경우 SC가 시스템에서 채널 데이터를 동기화하는 방법에 대한 구현 세부 정보를 배울 필요가 없습니다.

SCC

SCC는 2016 년 9 월에 도입되었습니다. SC는 여러 호스트에서 SC를 확장하기 위한 컴포넌트 모음입니다.

SCC는 설치가 쉬우며 뒤에서 일어나는 일에 대해 많이 알 필요 없이 수평적 확장성을 제공합니다. Kubernetes위에 SCC를 실행하면 위아래로 스케일 업이 자동으로 처리됩니다. SCC 사용에 대한 전체 안내서는 여기에 있습니다. SCC를 사용하는 경우 '수동으로 크기 조정'에 대한 아래 섹션을 읽을 필요가 없습니다.

수동으로 크기 조정

수평적 확장의 목표는 최적의 방법으로 트래픽을 모든 사용 가능한 시스템에 분산하는 것입니다. SocketCluster의 컨텍스트에서 수평 확장은 두 가지 특정 문제로 귀결됩니다.

  1. 들어오는 클라이언트 연결을 보낼 호스트를 어떻게 선택합니까?
  2. 한 클라이언트가 채널에 데이터를 게시할 때 다른 호스트의 해당 채널에 가입 한 다른 클라이언트가 채널 데이터를 실시간으로 수신하는지 어떻게 확인할 수 있습니까?
첫 번째 과제에 접근하는 데는 여러 가지 방법이 있습니다. 예를 들면 다음과 같습니다.

무작위로 호스트 URL을 선택하고 클라이언트 소켓의 connect() 메서드에 옵션으로 전달하여 각 클라이언트를 호스트 중 하나에 직접 보낼 수 있습니다.
로드 밸런서를 사용하여 들어오는 연결을 대상 호스트에 고르게 분산할 수 있습니다. 타사 서비스를 사용할 수도 있고 직접 설정할 수도 있습니다. SocketCuster v1.xx를 사용하는 경우 sticky로드 밸런서(예 : IP 주소 기반의 Sticky)를 사용해야 합니다. - 버전 v2.0.0 이상에서는 사용하지 않아도 됩니다. (이는 우리가 stateful HTTP 폴링 지원하지 않는 이유입니다). 사용하는 로드 밸런서는 WebSocket을 지원해야 합니다. HAProxy와 NGINX의 새로운 버전을 사용하세요. SC와 함께 작동하도록 설정하고 최적화하기 쉬운 것으로 LoadBalancer.js도 있습니다.

서로 다른 컴퓨터에 연결된 클라이언트가 동일한 pub/sub 채널을 공유할 수 있게 하려면 실시간으로 별도의 SocketCluster 인스턴스 (호스트) 간에 채널을 동기화하는 효율적인 방법이 필요합니다. 이를 위해 SocketCluster는 brokerController 파일 (broker.js)에 Broker 객체를 제공하여 이를 정확히 수행 할 수 있습니다. SocketCluster는 인스턴스 채널을 동기화할 수 있는 인터페이스만 제공합니다. 이 기술을 구현하기 위해 어떤 기술/구현을 사용하든 상관하지 않습니다. pub/sub를 지원하고 분산 클러스터로 실행할 수 있는 한 MQTT(예 : Mosquitto), AMQP (예 : RabbitMQ), ZeroMQ 및 Redis가 모두 가능한 옵션입니다. 이러한 서비스를 설정하는 방법에 대한 자세한 내용은 이 가이드의 범위를 벗어납니다. 이러한 기술/프로토콜 중 일부를 읽거나 서드파티 서비스를 사용해야 합니다.

여러 대의 머신으로 확장할 수 있는 작업/서브 클러스터가 있다고 가정하면 SC 인스턴스/머신 간의 실제 동기화는 매우 간단합니다 - SocketCluster의 브로커 프로세스를 통해 수행할 수 있습니다 - 자세한 정보는 Broker API의 이벤트 섹션을 읽으십시오. 결과적으로 MQ 서비스는 SocketCluster 인스턴스 간의 연결 고리처럼 작동합니다. 또한 외부 서비스가 SocketCluser 채널과 동일한 시스템의 일부인 것처럼 상호 작용할 수 있습니다.

분산 MQ 서비스를 실행한 후에는 원하는 클라이언트를 사용하여 브로커 프로세스와 메시지 대기열 서비스 간의 이벤트를 릴레이 하면 됩니다. 설정은 간단합니다.

  1. 브로커 인스턴스에서 'subscribe'이벤트가 발생하면 MQ 클라이언트에서 MQ 서비스의 해당 채널을 구독해야 합니다.
  2. 브로커가 '구독 취소'이벤트를 발생하면 MQ 서비스에서 해당 채널의 구독을 취소해야 합니다.
  3. MQ 클라이언트에서 일부 채널 데이터를 수신할 때마다 broker.publish(channelName, data)를 호출합니다.

'subscribe'및 'unsubscribe'이벤트는 개별 클라이언트 소켓에 대해 트리거 되지 않습니다. 이는 워커 프로세스에 의해 시작됩니다. 작업자는 언제 브로커에 구독/탈퇴해야 하는지 선택합니다. '구독'이벤트가 발생하면 현재 브로커가 해당 채널에 대한 책임이 있습니다. '탈퇴'이벤트는 이 브로커가 더 이상이 채널에 책임이 없음을 나타냅니다.

SC 인스턴스에는 각각 여러 브로커 프로세스가 있을 수 있습니다. 이 경우 각 브로커는 최종 클라이언트에서 사용하는 모든 채널의 하위 집합을 담당합니다. 어댑터를 작성할 때 모든 채널이 동일한 브로커를 통과한다고 절대 가정해서는 안됩니다.

마지막 고려 사항으로 대기 시간을 최소화하기 위해 SC 인스턴스 (또는 가능하면 동일한 데이터 센터 내부)와 가까운 곳에 MQ 서비스를 배포하는 것이 가장 좋습니다.

Videos by Nick Kotenberg

017 NodeJS Socketcluster Horizontal Scaling
018 NodeJS Socketcluster Horizontal Scaling with Loadbalancer

socketcluster tutorial - 9. SSL을 적용한 상용 서비스 운영(Running in production (with SSL))

SSL을 적용한 상용 서비스 운영


SocketCluster에 시스템을 구축할 때 마스터 프로세스(server.js)에 런타임 구현을 배치하지 않는 것이 중요합니다. 이러한 구현은 worker(worker.js) 내부에 배치하는 것이 좋습니다. 마스터 프로세스와 달리 워커는 충돌할 때마다 (오류가 발생하지 않는 경우) 자동으로 재발행하고 서비스 중단을 최소화됩니다. 일반적으로 워커는 재발생하는데 1 초 미만이 걸리므로 사용자에게 투명해야 합니다. 마스터 프로세스는 일반적으로 초기 실행 구현을 넣고 장시간 실행되는 데몬 프로세스를 생성하기에 좋은 곳이지만 일단 시스템이 실행되면 오류가 발생하기 쉬운 논리를 실행하는데 이 프로세스를 사용하지 않아야합니다.

이러한 규칙을 따르는 경우 Node 명령을 사용하여 직접 SocketCluster 서버를 실행하면 실제 운영 환경에서 정상적으로 작동합니다. (인수 포함 예제).
nohup node server.js -w 2 -s 2 &
안심할 수 있도록 master를 자동으로 재생성하려면 forever를 사용하십시오.
npm install -g forever
설치한 후 다음과 같이 실행하십시오.
forever start --killSignal=SIGTERM server.js -w 2 -s 2
어떤 경우든 서버 기반 코드를 강제로 업데이트하기 위해 거의 다운타임 없는 배포를 수행하는 경우 마스터 프로세스에 SIGUSR2 신호를 보낼 수 있습니다. 자세한 내용은 이 문제를 참조하십시오.

SSL

프로덕션 환경에서 SC를 실행할 때 고려해야 할 또 다른 중요한 점은 일부 오래된 프록시가 WebSocket 트래픽을 차단할 수 있다는 것입니다. 이 문제를 방지하려면 SC 인스턴스에 키/인증서 SSL쌍을 제공하여 HTTPS/WSS를 통해 앱을 제공해야합니다.

SSL/TLS를 사용하도록 SC를 구성하려면 부팅 옵션을 설정해야합니다. '프로토콜'을 'https'로 설정하고 인증서 및 키가 포함 된 개체를 'protocolOptions'에 제공하십시오. protocolOptions 객체는 Node.js의 https 서버에 전달하는 options 객체와 정확히 동일합니다. 여기를 참고하십시오.

SocketCluster를 Kubernetes 환경에 배포하는 경우 server.js에서 TLS/ SSL 자격 증명을 지정할 필요가 없습니다. TLS / SSL은 K8에서 제공하는 ingress load balancer에서 처리됩니다. SCC를 참조하십시오.

socketcluster tutorial - 8. SocketCluster로 풀스택 발행/구독 (Full stack pub/sub with SocketCluster)

SocketCluster 풀스택 펍섭(발행/구독)


Socket.io 스타일의 emit/on 기능 외에도 SocketCluster를 사용하면 JavaScript(NodeJS 서버)를 사용하여 클라이언트 또는 서버의 실시간 pub/sub 채널과 상호 작용할 수 있습니다. 미들웨어 기능을 정의함으로써 SC는 실시간 데이터를 완벽하게 제어 할 수 있습니다. 미들웨어는 클라이언트가 특정 채널을 구독하고 게시하는 것을 차단하는 데 사용할 수 있지만 다른 클라이언트에 도달하기 전에 실시간 스트림을 백엔드로 변환하는데도 사용할 수 있습니다.

이 다이어그램은 SC v1.x.x의 아키텍처를 나타냅니다. SC v2.0.0+는 고정 로드 밸런서 계층(sticky load balancer layer)이 없습니다. 대신 워커는 동일한 포트를 공유하고 어느 포트가 가장 바쁜지를 기준으로 새로운 연결을 선택합니다. 다이어그램은 조금 일반적이지만 채널 1, 채널 2, 채널 3 ...은 고객이 참여할 수있는 다양한 대화방입니다. 각 방은 '수학', '물리학' , '화학'...과 같은 특정 ​​주제를에 집중할 수 있습니다, '물리학'방에 게시한 모든 메시지를 듣기 위해서는 클라이언트에서 다음과 같이 해야 합니다.
// SocketCluster API v1.0.0
var physChannel = socket.subscribe('physics');
physChannel.watch(function (data) {...});
물리학 방에 메시지를 전달하기 위해선 다음과 같이 호출합니다:
socket.publish('physics', messageData);
... 혹은
physChannel.publish(messageData);
여러 사용자가 채널을 공유 할 필요는 없습니다. 개별 사용자를 위해 채널을 설정할 수 있습니다. 예를 들어 사용자 이름이 'bob123'인 사용자는 'bob123'채널을 구독하고 시청할 수 있습니다. 그러면 bob123으로 데이터를 보내려는 다른 사용자는 다음과 같이 간단하게 호출할 수 있습니다:
socket.publish('bob123', {from: 'alice456', message: 'Hi Bob!'});
기본적으로 SC는 누구나 원하는 채널을 구독하고 게시할 수 있습니다. 서버에서 미들웨어를 지정하여 특정 사용자가 특정 이벤트를 구독, 게시 또는 전송하는 것을 허용 또는 차단할 수 있습니다. 예를 들면:
scServer.addMiddleware(scServer.MIDDLEWARE_SUBSCRIBE, function (req, next) {
  // ...
  if (...) {
    next(); // Allow
  } else {
    next(req.socket.id + ' is not allowed to subscribe to ' + req.channel); // Block
  }
});
scServer.addMiddleware(scServer.MIDDLEWARE_PUBLISH_IN, function (req, next) {
  // ...
  if (...) {
    next(); // Allow
  } else {
    next(req.socket.id + ' is not allowed to publish to the ' + req.channel + ' channel'); // Block
  }
});
scServer.addMiddleware(scServer.MIDDLEWARE_EMIT, function (req, next) {
  // ...
  if (...) {
    next(); // Allow
  } else {
    next(req.socket.id + ' is not allowed to emit the ' + req.event + ' req.event'); // Block
  }
});
또한 SocketCluster는 이벤트를 클라이언트에 발행할 수 있는 서버 측(scServer.exchange)의 Exchange 객체를 제공합니다:
scServer.exchange.publish(eventName, data, cb);
전송한 이벤트는 소켓의 반대편(즉, 서버 → 클라이언트 또는 클라이언트 → 서버)으로만 전송됩니다. 반면에 채널에 발행한 데이터는 구독중인 모든 클라이언트 소켓으로 전송됩니다 (다른쪽엔 아무 것도 보내지 않습니다!).

클라이언트 소켓을 채널을 구독하려면 다음과 같이 하면 됩니다.
var channelObject = socket.subscribe(channelName);
그러면 들어오는 채널 데이터를 처리하기 위해 아래와 같이 합니다.
channelObject.watch(handlerFn);
클라이언트가 채널 이벤트를 수신하려면 구독 요청이 SUBSCRIBE 미들웨어를 통과해야합니다.

socketcluster tutorial - 7. 실패 처리 (Handling failure)

실패 처리


프로덕션의 실시스템은 시스템 실패를 처리 할 수 있어야합니다. 고려해야 할 가장 일반적인 실패 원인 중 하나는 연결 불량에 대한 가능성입니다.

SC의 이벤트 관련 메소드는 서버가 액션을 확인할 때 '콜백'함수를 최종 인수로 사용합니다. 메서드가 실패하면 콜백은 인수로 오류를 받습니다.이 경우 메서드 호출을 다시 시도하거나 사용자에게 메시지를 표시하여 문제를 알릴 수 있습니다.

다양한 오류를 처리하는 방법은 다음과 같습니다. (샘플 코드)

Client측

보내기

// Client code
socket.emit('ping', 'This is a ping', function (err) {
  if (err) {
    // 보내기 이벤트 실패, 재시도 혹은 사용자에게 계속할지 여부를 물어봄.
  } else {
    // 보내기 이벤트 성공
  }
});
콜백 인수를 전달하지 않으면 emit 메소드가 실패하지 않습니다. 이 경우 emit 호출은 이벤트를 중요도 낮음 (휘발성)으로 처리합니다. 이 기능은 초당 여러 번 이벤트를 내보내고 가끔 실패하는 경우 신경 쓰지 않는 경우에 유용합니다. emit 메소드에 콜백을 전달하면 상대에게 명시적으로 응답을 보내야 합니다. (그렇지 않으면 콜백이 시간 초과됩니다):
// Server code
socket.on('ping', function (data, res) {
  // ...
  if (success) {
    res(null, 'Success'); // 성공 메시지 돌려주기
  } else {
    res('Error message'); // 오류 반환
  }
});
res 함수의 첫 번째 인수는 오류(모든 JSON 호환 타입 또는 객체)입니다. 일반 메시지(오류 없음)를 보낼  경우 첫 번째 인수를 null로 해야합니다. 원하는 경우: res (123, 'This is the error message') 이와 같이 첫 번째 인수를 오류 코드로 사용할 수 있습니다.

발행하기

// Client code
socket.publish('pong', 'This is a pong', function (err) {
  if (err) {
    // 발행 실패, 재시도 혹은 사용자에게 계속할지 여부를 물어봄.
  } else {
    // 발행 성공
  }
});

구독하기

// Client code
var pongChannel = socket.subscribe('pong');

pongChannel.on('subscribeFail', function (err, channelName) {
  // 구독 실패 처리
});

pongChannel.on('subscribe', function (channelName) {
  // 구독 성공 처리
});

// pong 채널에서 발행한 데이터 다루기
pongChannel.watch(function (data) {
  // pong 채널이 데이터를 발행할 때 마다 실행합니다.
});

Server-side

보내기

// Server code
socket.emit('ping', 'This is a ping', function (err) {
  if (err) {
    // Failed to emit event, retry or log?
  } else {
    // Event was emitted successfully
  }
});
콜백을 제공하면 클라이언트에서 응답을 보내야합니다:
// Client code
socket.on('ping', function (data, res) {
  // ...
  if (success) {
    res(null, 'Success'); // 성공 메시지 돌려주기
  } else {
    res('Error message'); // 오류 반환
  }
});

발행하기

// Server code
socket.exchange.publish('pong', 'This is a pong', function (err) {
  if (err) {
    // 발행 이벤트 실패. 재시도 혹은 로그?
  } else {
    // 이벤트 성공
  }
});

socketcluster tutorial - 5. 인증 (Authentication)

인증


개요


v1.3.0 이전에는 SocketCluster의 인증이 세션을 중심으로 돌아갔습니다. v1.3.0부터 인증은 JSON 웹 토큰 (JWT)을 기반으로합니다. SC의 인증 토큰 시스템은 다음 문제를 해결하도록 설계되었습니다.

사용자가 자격 증명을 다시 입력할 필요없이 연결이 끊어진 상태를 복구한 후 로그인 상태를 유지할 수 있습니다.
하나만 사용하여 로그인하면 열려있는 모든 브라우저 탭에서 사용자를 인증 할 수 있습니다. (여러 브라우저 탭간에 인증 토큰 공유).
SC의 인증 시스템에 대한 중요한 설계 고려 사항은 작업해야하지만 특정 데이터베이스 엔진이나 기본 데이터 (사용자 계정 정보 포함)와 완전히 독립적이어야한다는 것입니다. 이를 달성하기 위해 SC는 JWT 인증 토큰의 개념을 도입해야했습니다.

간단히 말해서, 인증 토큰은 서버에서 비밀 authKey로 서명하고 인증 (로그인) 프로세스의 일부로 클라이언트에 전송하는 사용자 정의 Object/JSON입니다 (SocketCluster 생성자의 authKey 옵션은 여기 참조). 토큰의 데이터는 클라이언트에 제공할 때 서명하므로 토큰을 무효화하지 않고 토큰을 수정할 수 없습니다. 즉, 서버 소켓에 유효한 auth 토큰이 첨부되어 있으면 (socket.authToken 참조) 클라이언트의 토큰이 서버에 의해 서명되었으므로 서버의 데이터가 유효하다는 것을 알 수 있습니다.

인증 토큰에 대해 주의해야 할 중요한 사항 중 하나는 클라이언트가 성공적으로 인증 된 이후에 클라이언트에 제공해야하며 클라이언트와 서버 사이에 비밀로 유지되어야합니다 (다른 클라이언트와 공유되지 않음). SC의 인증 토큰은 특정 사용자와 관련된 모든 종류의 액세스 제어 정보를 저장하는 데 사용할 수 있습니다. 일반적으로 사용자 이름 데이터만 포함하는 간단한 토큰을 만드는 것으로 충분합니다:
{
  username: 'bob123'
}

인증 절차


SC에서 인증을 구현하는 올바른 방법은 하나가 아닙니다. WebSocket 연결 전에 HTTP를 통해 인증할 수 있으며 나중에도 할 수 있습니다.

HTTP-기반 절차
HTTP 기반 인증에 대한 자세한 내용은 이 토론을 참조하십시오.


WebSocket-기반 절차
웹소켓 기반 인증 절차에 대한 샘플입니다:
// Client code
socket = socketCluster.connect();
// 'connect'이벤트는 boolean 형인 'isAuthenticated' 속성이
// 있는 상태 객체를 전달합니다. 연결이 설정된 시점에 소켓이 유효한
//  토큰을 전달하면 true입니다.
// 핸드 셰이크 중에 JWT 인증에 실패하면 상태 객체에
// 'authError'속성 (Error 객체가 있음)을 포함 할 수 있습니다.
socket.on('connect', function (status) {
  if (status.isAuthenticated) {
    // goToMainScreen();
  } else {
    // goToLoginScreen();
  }
}
사용자가 인증되지 않아 로그인 화면으로 전송된다고 가정합니다. 우리는 클라이언트에서 '로그인'이벤트를 발생시켜 로그인합니다.
// Client code
var credentials = {
  username: 'alice123',
  password: 'thisisapassword654'
};
socket.emit('login', credentials, function (err) {
  // 이 콜백은 서버 응답을 처리합니다.
  // 필요하면 별도의 'loginResponse'이벤트를 수신할 수 있지만
  // 이와 같은 콜백 전달 패턴이 조금 더 효율적입니다.
  if (err) {
    // showLoginError(err);
  } else {
    // goToMainScreen();
  }
});  
그런 다음 서버에 로그인을 처리 할 수있는 몇 가지 코드가 있습니다:
// Server code
// 이는 당신이 MySQL을 데이터 베이스로 사용하는 경우를
// 살짝 단순화한 버전입니다.
socket.on('login', function (credentials, respond) {
  var passwordHash = sha256(credentials.password);
  var userQuery = 'SELECT * FROM Users WHERE username = ?';
  mySQLClient.query(userQuery, [credentials.username], function (err, rows) {
    var userRow = rows[0];
    var isValidLogin = userRow && userRow.password === passwordHash;
    if (isValidLogin) {
      respond();
      // 이렇게 하면 클라이언트에게 토큰을 제공하므로
      // 연결이 끊어 지거나 나중에 앱을 다시 방문 할 때
      // 다시 로그인 할 필요가 없습니다.
      socket.setAuthToken({username: credentials.username, channels: userRow.channels});
    } else {
      // Passing string as first argument indicates error
      respond('Login failed');
    }
  });
});

토큰 확인 및 사용

HTTP 또는 WebSocket 인증 절차 여부에 관계없이 동일한 방식으로 JWT 토큰을 검증하고 읽을 수 있습니다. SC가 토큰을 설정하거나 캡처한 후 이를 사용하는 가장 좋은 방법은 미들웨어 기능을 사용하는 것입니다 (예: 게시 미들웨어 사용):
// Server code
wsServer.addMiddleware(wsServer.MIDDLEWARE_PUBLISH_IN, function (req, next) {
  var authToken = req.socket.authToken;
  if (authToken && authToken.channels.indexOf(req.channel) > -1) {
    next();
  } else {
    next('You are not authorized to publish to ' + req.channel);
  }
});
이 경우 토큰에는이 게시 작업을 인증하는 데 필요한 모든 정보를 포함하지만 토큰 자체에 채널 목록을 저장할 필요는 없습니다. 사용자 ID나 이름이 있는 경우 데이터베이스를 확인할 수 있습니다. SC의 미들웨어에 대한 자세한 정보는 미들웨어 및 권한 섹션을 참조하십시오.

WebSocket 연결을 설정하기 전에 HTTP를 통해 인증을 수행하려면 직접 토큰을 처리해야합니다. 이 댓글을 참조하십시오. 이제 SC는 서버 측에서 토큰을 서명(생성)하고 검증하기위한 기본 'AuthEngine'을 제공합니다 - 'worker.auth'속성에서 workerController (worker.js)에 접근할 수 있습니다 - 여기 구현을 참조하십시오: 기본값 서버 인증 엔진. Node.js JSON 웹 토큰 라이브러리에 대한 자세한 정보는 jsonwebtoken에서 찾을 수 있습니다.

Videos by Nick Kotenberg

013 Client side logins authentication with SocketCluster with the client

2016년 12월 11일 일요일

socketcluster tutorial - 4. 디버깅 (Debugging)

디버깅


일반적인 NodeJS 프로세스를 디버그하는 것과 거의 같은 방법으로 SC 프로세스를 디버그 할 수 있습니다. 유일한 차이점은 SC에는 다양한 방식으로 서로 상호 작용하는 여러 종류의 프로세스가 있기 때문에 일반적으로 동시에 모두를 디버그하는 일은 없습니다. 이러한 이유로 SC에서는 --debug-workers--debug-brokers CLI 인수를 제공하여 워커와 브로커를 각각 디버그 할 수 있습니다. Node.js 버전 6.3.0 이상을 사용하는 경우 --inspect-workers--inspect-broker를 사용하면 외부 디버거를 실행할 필요가 없습니다.

저, Node.js v0.11.0 + (가장 최근의 안정 버전)을 사용하고 있는지 확인하십시오.

Node-inspector를 전역으로 설치하십시오 (Node.js v6.3.0 이상인 경우 이 단계를 건너 뜁니다).
npm install -g node-inspector
그런 다음 콘솔 창에서 다음을 사용하여 실행하십시오:
node-inspector
^ 전체 디버깅 세션에 걸쳐 이 콘솔을 자체 콘솔 (또는 백그라운드)에서 실행해야합니다 (개별 디버그 사이에서 다시 시작할 필요가 없습니다).

디버깅을 시작하려면 새로운 콘솔을 열어야합니다. Node를 사용하여 server.js 파일을 실행할 때 --debug-workers, --debug-broker, --inspect-workers 또는 --inspect-brokers 인수를 전달해야합니다. 서버 파일 이름 에 플래그를 추가하십시오. 그렇지 않으면 작동하지 않습니다.

예를 들면
node server --debug-workers
혹은
node server --debug-brokers
또는 (Node.js version >= 6.3.0)
node server --inspect-workers
또는 (Node.js version >= 6.3.0)
node server --inspect-brokers
첫 번째 워커의 기본 디버그 포트는 5859이고 두 번째 워커는 5860입니다 (각 워커마다 하나씩 증가합니다) - 디버그 메시지를 콘솔에 출력하여 어떤 디버그 포트가 열려 있는지 알려줍니다.

첫 번째 작업자의 디버그 콘솔을 열려면 이 주소를 Chrome 브라우저 (디버그 포트 5859)에 삽입해야 합니다. http://127.0.0.1:8080/debug?ws=127.0.0.1:8080&port=5859

Node.js> = v6.3.0 인 경우 콘솔에 제공된 두 번째 URL을 복사하여 첫 번째 워커를 디버그합니다 (제공된 첫 번째 URL은 master workerCluster 프로세스 용임).

또한 워커를 위한 사용자 시작 포트를 지정할 수도 있습니다. 첫 번째 포트는 워커에 할당됩니다. 클러스터 마스터 - SC 작업자를 관리하는 프로세스입니다.-는 일반적으로 디버깅 할 필요가 없습니다. 첫 번째 워커의 디버그 포트는 지정된 포트 + 1이고 그 뒤론 +1씩 증가합니다.
// workerCluster 프로세스는 포트 5999에서 디버깅할 수 있습니다.
// 첫 번째 워커는 포트 6000에서 디버깅 할 수 있습니다.
node server --debug-workers=5999
이는 브로커에도 적용됩니다:
// 첫 번째 브로커는 포트 5999에서 디버깅할 수 있습니다.
node server --debug-brokers=5999
Node.js v6.3.0 이상을 사용하는 경우 위의 'debug'키워드를 'inspect'로 대체하면 본질적으로 동일한 방식으로 작동합니다. 디버거 URL이 콘솔에 표시되는지 확인해야 합니다. 그냥 복사해서 브라우저에 붙여 넣기만 하면 됩니다.

마스터 프로세스(server.js)를 디버그하려면 일반적인 방식으로 하면 됩니다.
node --debug-brk server
혹은 Node.js >= v6.3.0이라면:
node --inspect server
^이 경우에도 순서가 중요합니다. (이번에는 --debug-brk 또는 --inspect가 서버 인수보다 에 있어야합니다!)

워커를 디버깅 할 때 가끔 특정 행에서 중단시키거나 계속 진행할 하고자 할 것입니다.(유휴 상태, 연결 대기 중). 이렇게 하려면 worker.js 코드에서 당신이 멈추고자하는 곳에 debugger; 명령을 추가해야합니다.

워커의 경우 전역 worker 객체(디버거 콘솔에서)에 접근할 수 있으므로 서버와 상호 작용하고 worker.exchange.publish( 'pong', 'This is a message for the pong channel')를 워커로부터 당신의 다른 시스템과 상호작용. (이 기능에 액세스하려면 코드의 아무 곳이나 debugger 문을 추가할 필요가 없습니다. 워커 변수는 모든 범위에서 액세스 할 수 있도록 전역에 노출됩니다.)

마찬가지로 브로커 프로세스를 디버깅 할 때 브로커 객체에 액세스 할 수 있으며 작업자와 마찬가지로 디버거를 통해 브로커와 직접 상호 작용할 수 있습니다.

주제를 조금 벗어나 : 여러 브로커를 사용하는 경우 각 브로커는 사용 가능한 모든 채널의 하위 집합만 관리합니다 (SC의 확장성에 대한 비밀스런 소스입니다). 따라서 브로커에게 publish()하면 아무도 메시지를 받지 못합니다. 특정 채널을 담당하는 브로커에서 publish()를 호출해야합니다.

2016년 12월 10일 토요일

탄력받은 김에 socketcluster 호스팅 서비스인 baasil.io 도 써보았다.

한달 무료 플랜이 있어서 광속가입.
나는야 시스템 어드민이기 때문에 유저따윈 얼마든지 만들 수 있다.

철자가 좀 헷깔린다. baasil.io다. 다소 웹페이지가 엉성한 느낌은 있다.
이런건 망하기 전에 잽싸게 빨대 꽂는 것이 인지상정.

아마도 대부분 유료를 겁내고 자신의 계정이 한달짜리 트라이얼로 소모되는게 아까우실거라고 생각하여 대신 가입해봄 -_-)v

가입 후 Email validation을 하고 나면
어서와. 소켓클러스터는 처음이지?

매우매우매우 심플하다.
Baasil.io manages your real-time infrastructure for you without compromising on flexibility. We provide you with a highly scalable, open source boilerplate (SCC) which you can modify as you like and then deploy to your own Kubernetes environment/cluster using a single command. The boilerplate we provide is designed to scale seamlessly across up to 1000 machines/hosts.
For the standard plan, Baasil.io gives you an isolated environment on a shared Rancher control panel. This setup is ideal if you have a relatively small number of machines (e.g. 1 to 20 hosts in your cluster) and are happy to look after your cluster using Rancher. If you would like to support more than 20 machines, want a completely hands-off experience when it comes to your infrastructure, or want your own dedicated Rancher control panel - We can make it happen with our flexible enterprise plan. If you would like to updgrade to the enterprise plan, you can contact us here.
You need to link your Baasil.io account to a valid GitHub account here before you can create your Rancher environment/cluster.
라고 한다.
Rancher라는 걸 쓰려면 깃허브 계정과 연동하라고 하는데 일단 패스
Try It을 보니
서비스키!! 키를 내놓으라!

오호. 서비스 키라는 걸 제공. 클라이언트 사이드에서 사용할 수 있다.
근데 크롬에서 개발자 콘솔 여는 단축키는 Cmd + Shift + J on OSX 아니야. Cmd + Option + J 라구!
<script src="https://baasil.io/socketcluster.js"></script>
요렇게 클라이언트에 붙이고
var socket = socketCluster.connect({
    query: {
      serviceKey: '섭수키:main'
    },
    channelPrefix: '섭수키:main#',
    hostname: 'service.baasil.io',
    port: 443,
    secure: true
  });
이렇게 접속해서

Subscribe
var myChannel = socket.subscribe('my-channel-name');
Watch
myChannel.watch(function (data) {
    // Handle incoming channel data here. You can set up multiple watchers per channel.
    console.log('myChannel data:', data);
  });
Unwatch
// The handler argument is optional (a function) - If not provided, it will unbind all watchers.
  myChannel.unwatch(handler);
Publish
myChannel.publish({foo: 'This is some JSON data'}, function (err) {
    // Callback to indicate whether or not publish was successful.
  });
Unsubscribe

myChannel.unsubscribe();
Check channel subscription state

myChannel.state // Can be 'unsubscribed', 'subscribed' or 'pending'
Check socket connection state
socket.state // Can be 'open', 'connecting' or 'closed'
Other useful operations...
Get array of watchers
// Get array of functions which are watching that channel.
  myChannel.watchers();
Subscribe again...
// Subscribe to a channel which was previously unsubscribed.
  myChannel.subscribe();
Get channel reference from socket
// This will not create any new subscriptions - Just get a channel reference.
  var myChannel = socket.channel('my-channel-name');
Get list of all subscribed channels
// Returns an array of channel names which are currently subscribed.
  // If the second argument is true, it will include channels which are pending subscription.
  socket.subscriptions('my-channel-name', true);
꿀팁을 마구 대방출.
뭐 이것만 알면 되겠네.
세상 참 좋구만.

그 다음은 https://docs.baasil.io/ 를 보고 CLI 도 설치해본다.
npm install -g baasil
설치 끗.
하나 만들어 봐야지. 그전에 docker가 있어야 하니 꼭 체크하고.
baasil create jwaujijangjiji 
해보니
Creating app structure...
[Success] Baasil.io app '/Users/spectrum/Documents/js/_app/jwaujijangjiji' was setup successfully.
끗.
node.js 가 그렇지 뭐;
실행해보자.
$ cd jwaujijangjiji
$ baasil run
Unable to find image 'socketcluster/socketcluster:v5.1.2' locally
v5.1.2: Pulling from socketcluster/socketcluster
5c90d4a2d1a8: Pull complete
ab30c63719b1: Pull complete
29d0bc1e8c52: Pull complete
f222342d2902: Pull complete
27808f091869: Pull complete
a5f3825caa0a: Pull complete
Digest: sha256:d466ab21339117e03aad3f97583cdb3320a4520f3d515f8dd6c1bfd19dba1c75
Status: Downloaded newer image for socketcluster/socketcluster:v5.1.2
2c597396d46e4c60348b5abfea8bc95bf099b1be0f9c9313c21859ff386d481e
[Success] App 'baasil01' is running at http://localhost:8000
docker 리파지터리에서 socketcluster 이미지를 땡겨온 다음 8000로 실행한다.
아주 좋아!
baasil --help
Usage: baasil [options] [command]
Options:
  -v            Get the version of the current Baasil.io installation
  --help        Get info on how to use this command
  --force       Force all necessary directory modifications without prompts
Commands:
  create <app-name>             Create a new boilerplate SCC app in working directory
  run <path>                    Run app at path inside container on your local machine
  restart <app-path-or-name>    Restart an app with the specified name
  stop <app-path-or-name>       Stop an app with the specified name
  list                          List all running Docker containers on your local machine
  logs <app-path-or-name>       Get logs for the app with the specified name
  deploy <app-path>             Deploy app at path to your Baasil.io cluster
  deploy-update <app-path>      Deploy update to app which was previously deployed
  undeploy <app-path>           Shutdown all core app services running on your cluster
맨드 라인 내용을 보니 대략 이렇다.
필요한 것만 딱 들어있네.
공통인 부분은 죄다 제외하고 서버 사이드엔 worker.js 와 package.json 나머지 client는 public안에 다 몰아놓았다.
안그래도 간단한데 더욱 간단하다.
docker와 kurbernate가 세상을 정말 많이 바꿨구나. 이젠 이런게 아무렇지도 않군.

다짜고짜 deploy 때려보자.
dockerhub 계정을 요구한다.
만들어만들어~
$ baasil deploy
? Enter your DockerHub username: bsio20161210
? Enter your DockerHub password: *********
? Enter the number of workers for each SocketCluster instance (Default: 1): 4
? Enter the number of brokers for each SocketCluster instance (Default: 1):
? Enter the Docker image name without the version tag (Or press enter for default: bsio20161210/
baasil01):
? Enter the Docker version tag for this deployment (Default: v1.0.0):
Sending build context to Docker daemon 228.9 kB
Step 1 : FROM node:6.3.0-slim
6.3.0-slim: Pulling from library/node

worker는 4개!
[Error] Failed to deploy the 'baasil01' app. Command failed: kubectl create -f /Users/spectrum/Documents/js/_app/csjBootstrap/baasil01/kubernetes/scc-broker-deployment.yaml
실패한다.
쩝, github 연동 먼저 해야지.

https://baasil.io/#!/dashboard?main-tab=account 에서 github account 넣어주고
https://baasil.io/#!/dashboard?main-tab=infrastructure 로 돌아오면 Rancher 생성이 활성화 된다.

TADA!
지금부터 대쉬보드인가!
생성생성

좋다. host 생성하자.
이것저것 눌러보자. 음... 잘만들었네.
EC2나 Azure는 쓰지 않는다. Custom으로 ㄱ

잘모르니까 디폴트.
5번에 Copy, paste, and run the command below to register the host with Rancher: 부분 아래에 있는 명령을 복사해서 터미널에 붙여넣자.

Unable to find image 'rancher/agent:v1.0.2' locally
v1.0.2: Pulling from rancher/agent
5a132a7e7af1: Pull complete 
fd2731e4c50c: Pull complete 
28a2f68d1120: Pull complete 
a3ed95caeb02: Pull complete 
7fa4fac65171: Pull complete 
33de63de5fdb: Pull complete 
d00b3b942272: Pull complete 
Digest: sha256:b0b532d1e891534779d0eb1a01a5717ebfff9ac024db4412ead87d834ba92544
Status: Downloaded newer image for rancher/agent:v1.0.2
5cc13082b79f9b58a488c456fdd1500de6b7f9450bd6ab42aa89517088c61336
docker: Error response from daemon: Mounts denied: 
The path /var/lib/rancher
is not shared from OS X and is not known to Docker.
You can configure shared paths from Docker -> Preferences... -> File Sharing.
See https://docs.docker.com/docker-for-mac/osxfs/#namespaces for more info.
..
오류가 나는데
sudo docker run -d --privileged -v /var/run/docker.sock:/var/run/docker.sock -v /var/lib/rancher:/var/lib/rancher rancher/agent:v1.0.2 https://localhost:8000/v1/scripts/ㅌㅌㅌㅌㅌㅌㅌㅌㅌㅌㅌㅌㅌㅌㅌ:ㅌㅌㅌㅌㅌㅌㅌㅌㅌㅌㅌㅌㅌ
ㅉㅉㅉㅉㅉㅉㅉㅉㅉㅉㅉㅉㅉㅉㅉㅉㅈ
이런식으로 주소를 localhost기준으로 바꿔주자. 디폴트는 8000번 포트.

아으 여기까지 해봤는데 지친다.
local로만 해보고 이미지 떠서 다른데 호스팅 하는게 낫겠어. 귀찮네.

#짐싸자


socketcluster tutorial - 3. 기본 사용법 (Basic usage)

기본 사용법

본 튜토리얼을 진행하기 전에 '시작하기'를 읽어 보아야 합니다.

일단 SocketCluster를 설정하면 server.js라는 JavaScript 파일이 만들어집니다.
// Server code
var SocketCluster = require('socketcluster').SocketCluster;
var socketCluster = new SocketCluster({
  workers: 1,
  brokers: 1,
  port: 8000,
  appName: 'app',
  // 주요 성능 향상을 위해 wsEngine을 'uws'로 전환하세요.
  wsEngine: 'ws',
  workerController: __dirname + '/worker.js',
  brokerController: __dirname + '/broker.js',
  socketChannelLimit: 1000,
  rebootWorkerOnCrash: true
});
이러한 옵션 중 일부를 이해하려면 SocketCluster가 서버에서 3가지 다른 종류의 프로세스 클러스터로 실행되는 것을 고려해야합니다.

마스터 프로세스 (server.js)


모든 것이 시작되는 곳입니다.

Workers


이것은 모든 비즈니스 로직이 있어야하는 곳입니다 - workerController는 실시간 소켓 연결 및 이벤트를 처리하기 위해 HTTP 서버 및 실시간 SocketClusterServer에 대한 로직을 설정할 수 있습니다.

Brokers


이것은 주로 SocketCluster 내부적에서 사용하며 모든 작업자가 서로 효율적으로 이벤트를 공유 할 수 있게합니다. 또한 이 데이터를 사용하여 세션 데이터를 저장하고 여러 대의 컴퓨터에서 수평적으로 응용 프로그램을 확장 할 수도 있습니다.

보일러플레이트 앱


workerController 파일 (worker.js)을 열면 httpServer와 scServer가 요청/연결을 수락하는 코드가 보입니다. 기본적으로 httpServer는 public/folder의 내용을 제공하는 Express(정적 서버 미들웨어 포함) 모듈에 연결됩니다:
// Server code
app.use(serveStatic(__dirname + '/public'));
httpServer.on('req', app);
보일러플레이트 앱에선 scServer는 들어오는 WebSocket 연결을 처리하고 클라이언트 소켓에서 사용자 정의 'ping'이벤트를 수신합니다 (다른 것들 중에서도):
// Server code
var count = 0;
scServer.on('connection', function (socket) {
  // ...
  socket.on('ping', function (data) {
    count++;
    console.log('PING', data);
    scServer.exchange.publish('pong', count);
  });
});

여기에서 'ping'이벤트는 클라이언트 소켓이 다음을 사용하여 클라이언트에서 ping을 내보낼 때마다 트리거됩니다.
// Client code
socket.emit('ping', 'This is a PING message')
이벤트를 보내는 것은 클라이언트와 서버간에 메시지를 전달하는 가장 간단한 방법이지만 메시지를 공유하는 유일한 방법은 아닙니다.

이 목록의 예약된 이벤트 이름을 제외하고 원하는대로 이벤트의 이름을 지정할 수 있습니다. 이는 SC 내에서 특별한 의미가 있습니다. 시스템에 많은 이벤트가있는 경우, 이벤트 이름을 지정하는 좋은 규칙은 '.'기호를 사용하는 것입니다. 형식은 'myNamespace.myEvent'입니다.

채널에 데이터를 발행할 수도 있습니다. 채널에 발행하면 한 번에 여러 클라이언트에 데이터를 보낼 수 있습니다. 채널에 등록된 클라이언트는 해당 채널에 발행한 모든 데이터를 수신합니다. 클라이언트와 서버 모두 채널에 발행할 수 있습니다 (미들웨어로 인해 채널이 차단되지 않는 경우). 채널은 주로 클라이언트와 클라이언트 간의 통신을 위한 것이지만 SC는 서버의 채널을 청취하는 방법을 제공합니다 (이 주제는 다른 튜토리얼에서 더 자세한 내용을 다룹니다).

위의 서버 측 코드 조각 하나는 다음과 같이 'pong'채널에 발행하고 있습니다.

// Server code
scServer.exchange.publish('pong', count);
SocketCluster에 연결되어 있고 'pong'채널을 구독하고 있는 클라이언트는 count 변수의 값을 받습니다. 클라이언트에서 코드는 다음과 같습니다.
// Client code
// New API as of SocketCluster v1.0.0.
var pongChannel = socket.subscribe('pong');
pongChannel.watch(function (count) {
  console.log('Client received data from pong channel:', count);
});
하나 이상의 채널을 구독 취소하려면 다음 단계를 따릅니다:
// Client code
socket.unsubscribe('pong');
앞서 설명한 것처럼 scServer.exchange.publish (...)를 사용하여 서버에서 채널에 발행할 수 있습니다. 편의를 위해 SocketCluster를 사용하면 클라이언트측에서 채널에 발행할 수도 있습니다:
// Client code
socket.publish('pong', 'This PONG event comes from a client');
여기서 문자열을 인수로 전달합니다. 채널 개체에 직접 데이터를 발행할 수도 있습니다. 다음 코드는 위와 똑같은 작업을 수행합니다:
// Client code
pongChannel.publish('This PONG event comes from a client');
때로는 특정 개인의 특정 채널에 대한 읽기 또는 쓰기 권한을 제한할 수 있습니다. 이러한 목적으로 SC를 사용하려면 미들웨어 기능을 활용하세요. 이에 대해 자세히 알아 보려면 "미들웨어와 권한" 가이드를 읽어보세요.

요약


socket.emit (event, data) 함수를 사용하면 클라이언트 소켓 1 개와 일치하는 서버 소켓 1 개 (클라이언트 소켓 1 개⇄서버 소켓 1 개—클라이언트와 서버간 1대1 통신)간에 메시지를 보낼 수 있습니다.

socket.publish (event, data) 및 channel.publish (data) 함수를 사용하면 여러 클라이언트 소켓 (n 개의 클라이언트 소켓 ⇄ n 클라이언트 소켓 - 클라이언트 간의 직접 통신)을 통해 그룹 메시지를 보낼 수 있습니다. 앞에서 설명한 것처럼 교환 객체를 사용하여 서버에서 발행을 호출 할 수도 있습니다.
// Server code
scServer.exchange.publish('foo', 123);
두 클라이언트 사이의 일대일 통신을 위해 게시를 사용할 수도 있지만 두개의 승인된 클라이언트만 동일한 채널을 공유할 수 있도록 특정 미들웨어를 설정해야합니다. 자세한 내용은 "미들웨어와 권한" 가이드를 참조하십시오.

비디오 Nick Kotenberg


007 Socketcluster Server/Client Communication Basic
008 Server/Client Data 1
009 Server/Client Data 2
010 Databases and SC 101
011 Server to Server Communication

socketcluster tutorial - 2. 시작하기 (Getting Started)

시작하기


SocketCluster를 시작하려면 Node.js가 설치되어 있어야 합니다. 이 지침에 따라 NodeJS를 설치할 수 있습니다. 또는 Baasil.io로 Docker 컨테이너에서 SocketCluster를 실행할 수 있습니다. - Kubernetes 환경에 앱을 배포하려는 경우 이상적입니다 - 여기를 참조하십시오.

Node가 설치되면 SocketCluster를 설치할 수 있습니다. SocketCluster를 설치하는 두 가지 방법이 있습니다. 가장 간단한 방법 프레임워크로 설치할 수 있고 보다 구체적인 요구 사항이있는 경우 클라이언트와 서버를 따로 설치할 수도 있습니다. 두 설정은 거의 동일한 API를 공유하므로 일반적으로 전환할 때 코드를 변경할 필요가 없습니다. 사실, socketcluster-server는 socketcluster (프레임 워크)의 직접적으로 종속됩니다.

SocketCluster를 독립 실행형 서버 및 클라이언트로 설치하려면 다음을 수행하십시오. 여기(서버)여기(클라이언트)의 지침을 따르십시오.

프레임워크로 설치하려면 (권장) :
npm install -g socketcluster
일단 설치되면, socketcluster create 명령은 새로운 SocketCluster 를 설치합니다. 예를 들어, socketcluster create myApp는 현재 작업 디렉토리에 myApp라는 디렉토리를 작성합니다.
socketcluster create myApp
번들된 패키지(webpack같은)에서 사용하려면
npm install --save socketcluster
npm install --save socketcluster-client
하고 서버에서
var SocketCluster = require('socketcluster').SocketCluster
그리고 클라이언트에서
var SocketCluster = require('socketcluster-client')
를 추가합니다.

SocketCluster 서버 프로그래밍


이 작업을 마치면 myApp으로 이동하여 node server.js를 사용하여 즉시 서버를 실행할 수 있습니다
node server.js
브라우저에서 http://localhost:8000/ 으로 이동하여 서버에 연결할 수 있습니다.

SocketCluster의 실시간 기능을 테스트하려면 브라우저의 개발자 콘솔을 열고 다음과 같이 입력하십시오:
// Client side
var socket = socketCluster.connect();
socket.emit('sampleClientEvent', {message: 'This is an object with a message property'});
'Sample channel message: 1' 메시지가 다시 나타납니다. - 서버는 sampleClientEvent 이벤트를 수신 한 다음 샘플 이벤트를 청취중인 모든 클라이언트에 게시합니다.

emit 및 publish 명령의 두 번째 인수로 JSON과 호환되는 거의 모든 것을 전달할 수 있습니다.

클라이언트 측의 socketCluster.connect () 메소드에 object형인 옵션을 사용할 수 있습니다. 자세한 내용은 socketCluster를 참조하십시오. 주요 SocketCluster JavaScript 클라이언트에 대한 자세한 내용을 보려면 여기를 클릭하십시오.

서버 측에서는 server.js 내의 코드를 편집하여 SocketCluster를 구성 할 수 있습니다. SocketCluster는 30가지 이상의 옵션을 제공하며 사용자의 특정 요구에 맞게 변경할 수 있습니다 (대부분 옵션은 선택 사항 입니다).

다음은 server.js 파일의 예제입니다 (주석 포함):
var SocketCluster = require('socketcluster').SocketCluster;
var socketCluster = new SocketCluster({
  workers: 1, // worker processes의 갯수
  brokers: 1, // broker processes의 갯수
  port: 8000, // 서버가 여는 포트 번호
  appName: 'myapp', // 고유한 앱 이름
  // 주요 성능 향상을 위해 wsEngine을 'ws'를 'uws'로 전환하세요
  wsEngine: 'ws',
  /* 워커/서버를 구성하는 JS 파일
   * 여기서 대부분의 백엔드 코드를 작성합니다.
   */
  workerController: __dirname + '/worker.js',
  /* 각각의 브로커들을 구성하는 JS 파일
   * 여러 시스템에서 수평으로 확장하는 데 유용합니다 (선택 사항).
   */
  brokerController: __dirname + '/broker.js',
  // 워커가 죽을 경우 재시작할지 여부 (기본값은 true)
  rebootWorkerOnCrash: true
});
SocketCluster는 여러 개의 프로세스 클러스터를 실행합니다. 각 프로세스에는 각 프로세스의 동작을 구성 할 수있는 자체 '컨트롤러'파일이 있습니다. 로드 밸런서용 컨트롤러, 워커용 컨트롤러 및 브로커 프로세스 용 컨트롤러가 있습니다. 가장 중요한 것은 (대부분의 응용 프로그램을 작성하는) workerController입니다.

그리고 그 다음


workerController (worker.js)에 있는 기존 코드를 살펴보고 만져보세요.

코드를 변경할 때 SocketCluster를 다시 시작하십시오. UNIX와 유사한 환경에서 실행중이라면 SIGUSR2 신호를 마스터 PID 순서로 보내어 새로운 소스 코드로 오직 워커들만 재시작할 수도 있습니다.

Nick Kotenberg의 비디오

socketcluster tutorial - 1. 소개 Introduction

소개

SocketCluster는 빠르고 확장성이 뛰어난 HTTP + WebSockets 서버 환경으로, 시스템/인스턴스의 모든 CPU 코어를 사용하는 다중 프로세스 실시간 시스템을 구축할 수 있습니다.
Node.js 서버를 단일 스레드로 실행해야하는 한계를 없애고 worker 충돌에서 자동으로 복구하여 백엔드를 복원합니며. 오류도 중앙 로그로 모아줍니다.

SocketCluster는 Docker 컨테이너의 Kubernetes에서 실행되도록 최적화되어 있습니다 (자세한 내용은 SCC 참조).

SocketCluster는 pub/sub시스템(브라우저 / IoT 장치까지)과 같이 작동합니다. - 실제로 필요한 특정 이벤트를 클라이언트에게 전달합니다. SC는 수직으로 (프로세스의 클러스터로서) 수평적으로 (여러 머신 / 인스턴스) 모두 확장 할 수 있도록 설계하였습니다.

SC는 모듈 구조로 설계하였으므로 express와 같은 다른 프레임 워크 위(또는 자신 만의 빌드!)에서 동작가능합니다. SC의 실시간 API는 Socket.io의 API와 비슷합니다.

SocketCluster를 독립형 프레임 워크(HTTP 및 WebSocket 서버로 작동)로 사용하거나 실시간 엔진으로 만 사용하고 클라이언트 스크립트를 별도로 제공할 수 있습니다. http://npmjs.org/socketcluster-client를 참조하십시오.

Twitter를 팔로우하세요. http://socketcluster.launchrock.com/ 에서 업데이트를 구독하세요.

이 사이트는 오픈 소스이기도 하며 Github 참여를 환영합니다.

게임에서


SC는 멀티 플레이어 온라인 게임 제작에 이상적입니다. Phaser 데모를 보십시오. 대역폭 소비를 줄이려면 sc-codec-min-bin과 함께 SC를 사용하는 것이 좋습니다. 이 코덱은 SC 메시지를 압축하여 유선을 통해 전송 될 때 이진 패킷으로 변환합니다. 또는 특정 게임/응용 프로그램에 최적화 된 자신만의 코덱을 작성할 수도 있습니다.

메모리 누출 프로파일


SC는 메모리 누수 여부를 테스트 하였습니다. 마지막 전체 메모리 프로파일 링은 v0.9.17 (Node.js v0.10.28)에서 수행되었으며 작업자 및 브로커 프로세스에 대한 검사가 포함되었습니다. 메모리 누수가 발견되지 않았습니다.

주요 공여자


Jonathan Gros-Dubois
Matt Krick
Alex Hultman
Anatoliy Popov
Sachin Shinde
Nick Kotenberg
Rob Borden
Nelson Zheng
Lihan Li
MegaGM
wactbprot

socketcluster 를 써보았다. 아주 좋았다.

일단 worker.js에
  scServer.on('connection', function (client) {
    console.log(`${client.id} is connected`);
  });
그리고 client쪽은
var socket = socketCluster.connect();
socket.on('error', function (err) {
  throw 'Socket error - ' + err;
});
socket.on('connect', function () {
  console.log('CONNECTED');
});
이쯤에서 시작해보자.
클라이언트가 시작하면 서버쪽에선 client.id 가 발급되는 것을 볼 수 있다.
QVmNv2hblXhynoXOAAAE is connected
아마 이런 식으로 응답할 것이다.

DDP처럼 RPC 와 Pub/Sub을 해보자.

먼저 단순 호출+응답 형태를 구현해보자.
서버는 socket.on('connect', ...); 가 다음에 이렇게 
    socket.on('message.send', function (data) {
      console.log(data);
    });
클라이언트에선 그저 크롬 창 열고
socket.emit('message.send', { message: 'PING' });
해보자.

서버쪽에서 PING 찍히면 오케이.
이 메시지를 Pub/Sub으로 해보자.
서버쪽 구현을 변경하자.
    socket.on('message.send', function (data) {
      console.log('message.send', data);
      scServer.exchange.publish('message.publish', {
        from: socket.id,
        message: data
      });
    });
클라이언트도 맞춰서 message.publish를 subscribe 하는 부분을 추가해보자.
var messageChannel = socket.subscribe('message.publish');
messageChannel.watch(function(data) {
  console.log('message', data);
});
하. 뭐지? 너무 좋쟎아? 멀티유저도 그냥 되네?
RxDDP Server보다 이걸 먼저 만들어야겠다.

https://gomix.com/#!/project/sc-chat
gomix에 아주 간단한 채팅 앱을 pub/sub을 써서 만들어보았다. 참조.

2016년 12월 8일 목요일

Chrome source map 먼지팁 (coffeescript/typescript/babel)

잘 되다가 갑자기 coffeescript/typescript/babel 등등의 디버깅이 sourcemap 연결 안된다면
크롬 디버거 열고 F1 누르고 Settings > Preferences > Sources > Enable Javascript source maps 를 체크해준다.


그러고 다시 크롬 디버거를 열어보면 Sources 탭에
요렇게 예쁘게 나온다.
갑자기 설정이 풀렸다 싶으면 당황하지 말고 Settings를 확인해보자.

2016년 11월 27일 일요일

tutorial - radio button을 이용한 tree 구조 만들기

http://jsbin.com/cikuga/edit?html,css,output

IE 호환을 위해 jQuery를 사용했다. 안해도 되지만 이 편이 그래도 좀 읽기 쉽지 않나 싶다.
접히고 펼쳐지는 트리구조를 만드는 데 있어 핵심 아이디어는 같은 깊이에 인접한(sibling ) 요소들끼리는 radio button을 사용하면 된다는 것이다.

가령

<input type="radio" name="group1">
<input type="radio" name="group1">
<input type="radio" name="group1">

이렇게 했을 경우 같은 이름(name)을 가지고 있으므로 셋 중 하나만 radio 버튼이 들어오고

<input type="radio" name="group1">
<input type="radio" name="group2">
<input type="radio" name="group2">
<input type="radio" name="group2">

<input type="radio" name="group1">
<input type="radio" name="group1">

이와 같이 구성하면 group2는 group2끼리 group1은 group1끼리 각각 구성할 수 있다.
따라서 각각의 radio button에 대한 id가

1
  1-1
  1-2
2
  2-1
    2-1-1
    2-1-2
3

일 경우엔 1,2,3을 top
1-1, 1-2는 1
2-1은 2
2-1-1, 2-1-2는 2-1 같이 name을 지정해주면 된다.

여기서 label의 for와 input의 id를 맞춰주면 label을 클릭해도 radio가 켜지니 같이 묶어주자.
    <input type="radio" name="top" id="r1">
    <label for="r1">Title of Tab 1</label>
이런 식이면 충분.
전체적으로 구성을 해보자. 하위 아이템도 있고 그게 링크인 경우도 있을 수 있다.

<ol class="acc">
  <li>
    <input type="radio" name="top" id="r1">
    <label for="r1">Title of Tab 1</label>
    <ol class="tab-content">
      <li>
        <input type="radio" name="t-1" id="r1-1">
        <label for="r1-1">Title of Tab 1</label>
        <div class="tab-content">
          cascaded!
        </div>
      </li>
      <li>
        <input type="radio" name="t-1" id="r1-2">
        <label for="r1-2">Title of Tab 1</label>
        <div class="tab-content">
          cascaded!
        </div>
      </li>
    </ol>
  </li>
  <li>
    <input type="radio" name="top" id="r2">
    <label for="r2">Title of Tab 1</label>
    <ol class="tab-content">
      <li>
        <a href="#">link</a>
      </li>
      <li>
        <a href="#">link</a>
      </li>
    </ol>
  </li>
  <li>
    <input type="radio" name="top" id="r3">
    <label for="r3">Title of Tab 1</label>
    <div class="tab-content">
      Some content....
    </div>
  </li>
</ol>

이와 같이 구성해보았다.

실제 렌더링은 아마도 이럴 것이다.
Label을 눌러도 radio가 잘 작동하는지 꼭 보자.

이제 CSS로 스타일링을 할 시간이다.
Label을 눌러도 되니 radio 버튼은 안봐도 된다.
input[type=radio] {
  display: none;
}
숨기자.
그리고 대신 + 표시를 달아주자.
label:before {
  content: "+";
  position: relative;
  left: -2em;
}
label 위치보다 2글자 왼쪽에 content를 사용해서 "+"를 넣어줬다.
상대좌표니까 position을 relative로 하자.
이미지를 넣으려면 content: url(xxx.png) 식으로 지정하면 된다.

닫혀 있을 때 상태는 .tab-content 아래에 넣어서 숨기도록 한다.
.tab-content {
  display: none;
}
이걸로 닫힌 상태는 완성.

다음은 펼친 상태를 구현할 차례인데
"라디오 버튼이 checked 일때 인접한 .tab-content가 보이도록"
하면 된다.
그리고 label:before 에 있던 + 도 - 로 바꿔주면 좋겠다.
input:checked + label:before {
  content: "-";
}
input이 checked일때 + (바로 뒤에 인접한) label:before 의 content를 - 로 지정한다.
마찬가지로,
input이 checked일때 ~ (sibling이면서 뒤쪽 어딘가에 있는) display: none이던 .tab-content도 보이게 하자.
input:checked ~ .tab-content {
  display: block;
}
간단?
이것만으로도 OK.

label:before 를 선택할 때 +대신 ~로 써도 되는거 아녀요? 라고 물어보면
그렇다! 라고 말할 수 있다. ~는 +를 포함하니 상관없다.

여기까지만이면 좋겠는데 선택해서 펼쳐진 상태에서 label을 또 클릭하면 닫게 하고 싶을 수 있다.
이건 CSS만으론 어렵고 약간 코드가 필요하다.
  var selectedItemId = undefined;
  $('input', handler).click(function(e) {
    var t=e.target;
    if (t.id === selectedItemId) {
      t.checked = undefined;
      selectedItemId = undefined;
    } else {
      selectedItemId = t.id;
    }
  });
radio는 한번 선택을 하면 같은 그룹에서 undefined로 지정하기 전까진 항상 어딘가가 checked인 상태이다.
따라서, 이전에 선택한 radio와 같은 걸 클릭하면 checked를 undefined로 지정한다.
약간 hacky 한 구현이라고 볼 수 있다.

마지막으로 radio 대신 checkbox 로도 바꿔도 보고 어떻게 다른지 관찰하면 더욱 좋겠다.

2016년 11월 22일 화요일

Meteor DDP subscribe 처리 시 주의할 점

Meteor에서 logout 시 독특한 패턴으로 websocket이 날아오기 때문에 주의해야한다.

먼저 logout을 보내면
["{\"msg\":\"method\",\"method\":\"logout\",\"params\":[],\"id\":\"3\"}"]

가입 되있던 모든 publish에 영향 받는 collection이 removed 된다.
a["{\"msg\":\"removed\",\"collection\":\"users\",\"id\":\"ySWmTt329QeLQZTEc\"}"] 80
23:56:26.494
.........

a["{\"msg\":\"ready\",\"subs\":[\"CPSzK3DsirQq4fSmo\",\"87ojrAZZKFwu9LTeH\",\"5ynAG9oTZg7i3DMCs\",\"KZBaQRzyPiF33BoLz\",\"w3JwjFeWaFmxXiiaL\",\"ZM9oXYRjZ7cfSxvMY\",\"Q7XAmPJC35NjLdBYL\"]}"] 189
23:56:26.529

정체불명의 subs 가 array로 뭉텅 날아오고

a["{\"msg\":\"updated\",\"methods\":[\"3\"]}"] 46
23:56:26.530

logout method 에 대한 updated 와

a["{\"msg\":\"result\",\"id\":\"3\"}"]

result 가 id번호 3을 알려주면서 떨어진다.

여기에서 조심할 것이 subscribe ready 일때 무언가 처리를 해놓았다면 (가령 login등)
logout 할때 array랑 겹치지 않게 조심해 줘야할 필요가 있다.

Rx의 Subscirbe로 묶어 놨으면 반드시 안에서 unsubscribe / dispose 를 하자.

2016년 11월 15일 화요일

decaffeinate hack - Rx.js 를 import 해보자!

http://decaffeinate-project.org/repl
평소에 coffee를 좋아하지만 ecma6로 바꿔서 보여줘야 좋아하는 분들이 종종 있어서 decaffeinate를 쓰다보니 나름 console.log 만 띡 나오는게 꽤 쓰기 좋아서 자주 쓰는데.
쓰다보니 아쉬운 점이 외부 라이브러리를 불러올 수가 없어서 약간의 hack을 해보기로 했다.
script = document.createElement('script')
script.src = "//cdnjs.cloudflare.com/ajax/libs/rxjs/5.0.0-rc.2/Rx.js"
x=document.getElementsByTagName('script')[0]
x.parentNode.insertBefore script, x
단순하게 생각하면 이런 식
script tag을 하나 만들고 src를 Rx.js CDN 라이브러리로 지정하고 insertBefore를 사용해서 밀어넣으면 될거라고 생각했는데
repl.js?t=2015-03-09T08:30:22-07:00:7 Uncaught Error: module is not supported in the browser, you need a commonjs environment such as node.js/io.js, browserify/webpack etc
이런 오류가 난다. 보니까 의도적으로 decaffeinate에서 "module", "exports", "require" 이라는 말을 쓰면 저지하도록 되있더라
  ["module", "exports", "require"].forEach(function(commonVar){
    Object.defineProperty(window, commonVar, {
      get: function () {
        throw new Error(commonVar + " is not supported in the browser, you need a commonjs environment such as node.js/io.js, browserify/webpack etc");
      }
    });
  });
이 부분. Object.defineProperty 를 재정의 하기는 그렇고. (쓸데없는 짓들을 -_-++ )
그냥 Rx.js 를 고치기로 마음 먹음. RxJS 5.0.0 rc3 기준으로 github(https://github.com/acidsound/RxJS_pure)에 하나 땄다.
module 하고 exports 를 삭제하고 올린 뒤
script = document.createElement 'script'
script.src="//cdn.rawgit.com/acidsound/RxJS_pure/master/Rx.js"
scrSelf = document.getElementsByTagName('script')[0]
scrSelf.parentNode.insertBefore script, scrSelf
script.onload = -> startApp()
startApp = ->
  console.log "init program"
  Rx.Observable.range 1, 5
    .subscribe (o)->
      console.log o
잘 작동한다.
즐거운 Rx 라이프!


2016년 11월 6일 일요일

Bluestacks OS X를 android 개발용으로 쓰는 법

먼저 docker 를 설치했다면 꺼준다.
둘 다 가상화를 쓰는 시스템이라 충돌한다.

vi ~/Library/Preferences/com.BlueStacks.AppPlayer.plist
로 들어가서
width 와 height 부분을 바꿔준다.
<key>Width</key>
<integer>420</integer>
<key>Height</key>
<integer>700</integer>
420x700 으로 바꾸면 720p 노트북에서 그럭저럭 볼만하다.

2016년 10월 25일 화요일

RxJS - ReactiveX 인터뷰

A: 왜 RxJS입니까
B: javascript는 참 쉽고 친숙한 언어죠.
A: 별로 그렇게 생각 안합니다만.
B: 그래서 좀 어렵고 있어보이는게 뭘까 싶어서...
A: 네?
B: 함수형이라는게 유행하기도 하고
f(x) 좋쟎습니까? 미스테리~ 미스테리~ 정수정짱짱 으아아

이런 수학선생님이라면 수포자 따윈
A: ...
B: 그리고 반응형이라는 말 뭔가
A: 뭔가?
B: 대충대충해도 막 알아서 할거 같고...
A: 그럴리가요?
B: 안그렇겠죠?
A: 네
B: 네

(잠시만 기다려주세요)

A: 그래도 뭔가 매력이 있으니 이렇게 시간을 내셔서 이것저것 Rx에 대해 글도 쓰고 이야기도 하고 그러시는거 아닌가요?
B: 매력이라.
으음.
제가 팔꿈치 터널 증후근이 좀 있어요.
오른손 세끼손가락, 약지손가락이 저립니다.
A: 무슨 상관이?
B: 그래서 각종 괄호를 쓰는게 너무 힘듭니다.
소중대괄호 만든 사람 죽었으면.
Hello world (ASCII):

A: 이미 옛날에 돌아가셨겠죠.
B: 그렇겠네요.
아무튼 그래서 소중대괄호 의존이 적은 커피스크립트를 쓰는데요.
A: 빨리 본론을 말씀해주시죠.
B: 커피스크립트에서 가로로 80자 이상쓰면 Line exceeds maximum allowed length 라고 경고해요.
A: 그래서요?
B: 근데 Rx를 쓰면 코드를 가늘게 쓸 수가 있더라구요.
A: 호오?
B: 그리고 = 쓰는 것도 너무 힘듭니다.
A: 네?
B: 오른손을 쓰쟎아요.
A: ...
그러니까 정리하면
1. 괄호가 힘들다
2. 커피를 쓴다
3. 커피는 길게 쓰면 경고
4. Rx를 쓰면 코드가 가늘다
5. 대입문을 줄이고 싶다.
B: 네
하지만 5번은 생각보다 별로...
A:
B:

B: 아!
A: ?
B: 코드가 가늘어서 좋은 점이.
A: 네.
B: 핸드폰에서 코드를 보기 좋습니다.
A: ... 왜 팔꿈치 터널 증후근이 안 낫는지 알겠습니다.
B: 도와주세요.
쇠고기 사묵으면 나을 것 같습니다.

고오오기. 고기하면 소오고오기이


A: (모르겠고) 사실 그런건
array function(map, filter, reduce, concat)만 써도 비슷하쟎습니까.
사실 비동기 처리가 중요한거 아닙니까?
B: 비동기 까짓거 promise도 있고 걍 callback해도 되고
A: 여기까지 와서 시비 거시는 겁니까?
B: 뭐 얼마나 대단한 코드를 짠다고 callback 지옥 걱정을 합니까.

하지만 방심하면 금방...

A: 대단한 거 안짜도 빡센데요.
B: object literal 잘 쓰세요.
A: 싫어요.
B: 저도 별로...

A: 아무튼 지적 허영심도 충족시키고 손목 터널도 덜고
폰에서도 보기도 짱짱맨 라이브러리란 거죠?
B: 그리고 한번 배워놓으면 Polyglot이라서 다른 언어에서도 쓸 수 있습니다.
A: 그렇죠? 그건 참 좋은 거 아닌가요. 기껏 배워놨는데 본전 생각도 나고
B: 사실 UniRx(Unity+Rx) 같은 걸 보면 꼭 그런 것만도...
A: 그래도 개념을 이해하면 두루 도움이 되겠죠?
B: Go같은 경우를 보면 Channel이 더 좋고 쉬운데 굳이...
A: ...하지말까요?
B: 도와주십쇼.
A: 네, 협조부탁드립니다.
B: 네. 근데 저도 별로 아는게 없어서.
A: 모르는 거 부탁 드린적 없습니다.
B: 미흡하나마 잘 부탁드리겠습니다.
A: 네, 전혀 겸손처럼 느껴지지 않는군요.
B: 저야 워낙 신실한 사람이라서요.

A: Rx는 어떤 경우에 쓰면 좋을까요?
B: 연속적인 데이터가 예상할 수 없는 지점에 발생할 때 사용하면 좋습니다.
A: 이제까지 중 제일 말같은 말씀이시네요.
B: 저야 워낙 신실한 사람이라서요.
A: 못들은 걸로 하겠습니다.
좀 더 구체적으로 어떤 상황이 있을까요?
B: 키보드 입력, 마우스 처리, AJAX 호출, 파일 읽고 쓰기, 배치작업 스케쥴링, 각종 네트웍 처리 등등이 있겠죠. 이 모든 것들을 다 스트림으로 볼 수 있습니다.

그러하다.

B: 덤으로 전역변수의 사용을 지양하는 효과도 있어서 실수로 인한 외부 변수 오염으로부터 안전한 프로그래밍을 하는데 도움이 됩니다.
A: 튜토리얼은 앞으로 어떤 식으로 진행할 건가요?
B: 개론은 어짜피 reactivex.io 에 한글 문서도 있고 예제나 트레이닝 같이 따라해볼 수 있는 쪽으로 번역해볼까 합니다.
보신 분들은 알겠지만 발번역 오역이 난무하니 상처받지 않게 지도편달(?) 부탁드립니다.
A: 좋은 말씀 감사합니다. 뭔가 주객이 전도된 듯한 느낌이 드는군요.
B: 별말씀을요.

2016년 10월 23일 일요일

RxJS 에서 requestAnimationFrame 을 사용하려면?

http://jsbin.com/qosigic/edit?html,js,output

소스는 이쪽.

게임과 같은 분야는 타이밍 처리가 매우 중요하기 때문에 UI를 갱신하는 무한 루프를 놓고 delta 시간을 얻어와서 처리하는 로직을 많이 쓰는데
이걸 Javascript 에서 할 땐 전통적으로 setTimeout 을 걸어놓은 함수를 재귀하는 식으로 썼는데 문제는 setTimeout(setInterval도 마찬가지)이 굉장히 부정확한 타이밍을 가지고 있었고 이를 보완하기 위해 requestAnimationFrame 이라는 것을 만들어 사용하기 시작했다.
문제는 역시 지원하지 않는 몇몇 브라우저(ex. IE < 10)들 때문에 안타깝게도 RxJS 5.x 의 defaultScheduler에선 setTimeout(https://github.com/Reactive-Extensions/RxJS/blob/6dac0365ad22f87a92197fc4dcee70e72a11ddbb/src/modular/scheduler/defaultscheduler.js#L119)을 쓰고 있는데
물론 권장하는 방식은 https://github.com/Reactive-Extensions/RxJS/tree/8fa95ac884181fb6cbff8ce7c1d669ffb190f5e4/examples/crop 의 예처럼 RequestAnimationFrameScheduler 를 사용하는 것이지만

RxLua 처럼 기본으로 타이머가 없고 외부패키지에 의존하는 환경도 있고해서
기본 RxJS 환경에서 직접 만들어보기로 했다.

Scope 을 위해 일단 function으로 감싸보았다.
(function() {
  var canvas=document.getElementById('canvas1');
  var ctx = canvas.getContext('2d');
  var start = 0;
  var step = function(timestamp) {
    if (!start) start = timestamp;
    var progress = timestamp - start;
    ctx.clearRect(0,0,canvas.width,canvas.height);
    ctx.fillText("legacy: "+progress.toFixed(2), 10,10);
    window.requestAnimationFrame(step);
  }
  window.requestAnimationFrame(step);
})();
이게 아마 보통 requestAnimationFrame 을 사용하는 패턴일 것이다.
그러면 Rx 에서 subscribe 일때 처리해야하는 부분은 어디일까?
실제로 UI를 갱신하는 ctx 부분일 것이다.
(function() {
 var canvas=document.getElementById('canvas1');
 var ctx = canvas.getContext('2d');
 var start = 0;
 var step = function(timestamp) {
   if (!start) start = timestamp;
   var progress = timestamp - start;
   /* 여기부터 */
   ctx.clearRect(0,0,canvas.width,canvas.height);
   ctx.fillText("legacy: "+progress.toFixed(2), 10,10);
   /* 여기까지 */
   window.requestAnimationFrame(step);
 }
 window.requestAnimationFrame(step);
})();
이 부분을 분리해보자.
가장 간단한 방법은 역시 Subject 로 만드는 방법이겠다.
stepSubject.subscribe(progress=>{
  ctx.clearRect(0,0,canvas.width,canvas.height);
  ctx.fillText("Rx Subjeect: "+progress.toFixed(2), 10,10);
});
이렇게 실제로 progess 가 넘어오는 것을 받는 subscribe 를 만들고
stepSubject 를 생성한 뒤 루프 안에서 stepSubject.next 에서 progress 를 건내주도록 하자.
(function() {
  var canvas=document.getElementById('canvas2');
  var ctx = canvas.getContext('2d');
  var stepSubject = new Rx.Subject();
  var start = 0;
  var step = function(timestamp) {
    if (!start) start = timestamp;
    var progress = timestamp - start;
    stepSubject.next(progress);
    window.requestAnimationFrame(step);
  }
  window.requestAnimationFrame(step);
  stepSubject.subscribe(progress=>{
    ctx.clearRect(0,0,canvas.width,canvas.height);
    ctx.fillText("Rx Subjeect: "+progress.toFixed(2), 10,10);
  });
})();
간단하다. 별로 크게 건들지 않고 분리를 했다.

scope을 생각했을 때 반복하는 step function이 Observable 안에 있으면 좋겠다 싶은 생각이 든다.
start 와 step을 Observable.create 안에 넣고 .next 로 쏘아보자. subscribe는 동일하다.
(function() {
  var canvas=document.getElementById('canvas3');
  var ctx = canvas.getContext('2d');
  var stepObservable = Rx.Observable.create(observer=>{
    var start = 0;
    var step = function(timestamp) {
      if (!start) start = timestamp;
      var progress = timestamp - start;
      observer.next(progress);
      window.requestAnimationFrame(step);
    }
    window.requestAnimationFrame(step);
  });
  stepObservable.subscribe(progress=>{
    ctx.clearRect(0,0,canvas.width,canvas.height);
    ctx.fillText("Rx Observable: "+progress.toFixed(2), 10,10);
  });
})();
이렇게 옮기면 Rx.Observable 안에서 requestAnimationFrame 을 제어할 수 있다.
개인적으로는 이런 상황이라면 start 와 step 의 Observable 안에 scope 을 가지고 있는 후자를 더 추천한다.

2016년 10월 22일 토요일

RxJS Basic - 기초

http://reactivex.io/rxjs/manual/tutorial.html 글을 대충 번역해서 쓰는 글입니다.
jsbin/codepen 같은 곳에서 RxJS 라이브러리를 추가한 후 연습해봅시다.
현재 가장 최근 버전은 https://cdnjs.com/libraries/rxjs/5.0.0-rc.1 에서 확인하세요.

  1. Observable 로 변환하기
    1. 하나 혹은 n 개의 값으로부터

      Rx.Observable.of('foo', 'bar');
      =>foo
      =>bar
    2. 배열로부터

      Rx.Observable.from([1,2,3]);
      =>1
      =>2
      =>3
    3. 이벤트로부터

      Rx.Observable.fromEvent(document.querySelector('button'), 'click');
      =>button을 누를 때 마다 event로 변환
    4. Promise로부터

      Rx.Observable.fromPromise(fetch('/users'));
      =>/user 주소의 내용을 fetch한 것을 변환
    5. 마지막 인자가 콜백인 경우 콜백으로부터

      /* node.js */
      var exists = Rx.Observable.bindCallback(fs.exists);
      exists('file.txt').subscribe(exists => console.log('Does file exist?', exists));

      var rename = Rx.Observable.bindNodeCallback(fs.rename);
      rename('file.txt', 'else.txt').subscribe(() => console.log('Renamed!'));
  2. Observable 만들기
    1. 외부로부터 새로운 이벤트를 생성한다.

      var myObservable = Rx.Subject.create();
      myObservable.subscribe(value => console.log(value));
      myObservable.next('foo');
    2. 내부에서 새로운 이벤트를 생성한다.

      var myObservable = Rx.Observable.create(observer => {
        observer.next('foo');
        setTimeout(() => observer.next('bar'), 1000);
      });
      myObservable.subscribe(value => console.log(value));
    • 어떤 것을 선택할지는 시나리오에 따라 선택할 수 있습니다.
      일반적인 Observable은 당신이 시간이 흘러가면서 값을 생성하는 기능을 구현할때 좋습니다.
      일례로 websocket 연결 같은 것을 들 수 있다.
      Subject를 사용하면 어디서나 새로운 이벤트를 작동할 수 있으며 기존의 Observable과 연결할 수 있습니다.
  3. 흐름(Flow)을 제어하기

    // "hello world"라고 쳐봅니다.
    var input = Rx.Observable.fromEvent(document.querySelector('input'), 'keypress');

    // 2글자 이하로는 필터링합니다
    input.filter(event => event.target.value.length > 2)
      .subscribe(value => console.log(value));
    // "hel"

    // 이벤트를 지연시킵니다.
    input.delay(200)
      .subscribe(value => console.log(value));
    // "h" -200ms-> "e" -200ms-> "l" ...

    // 매번 200ms 동안 한번만 받아들입니다.
    input.throttleTime(200)
      .subscribe(value => console.log(value));
    // "h" -200ms-> "w"

    // 마지막 200ms 후에 발생한 것만 통과시킵니다.
    input.debounceTime(200)
      .subscribe(value => console.log(value));
    // "o" -200ms-> "d"

    // 3개의 이벤트만 받습니다.
    input.take(3)
      .subscribe(value => console.log(value));
    // "hel"

    // 다른 옵저버블이 이벤트를 발생시킬 때 통과시킵니다.
    var stopStream = Rx.Observable.fromEvent(document.querySelector('button'), 'click');
    input.takeUntil(stopStream)
      .subscribe(value => console.log(value));
    // "hello" (click)
  4. 값(Value)을 만들기

    // "hello world" 라고 쳐봅니다.
    var input = Rx.Observable.fromEvent(document.querySelector('input'), 'keypress');
    // 새로운 값을 내보냅니다.
    input.map(event => event.target.value)
      .subscribe(value => console.log(value));
    // "h"

    // 값 뽑아내기
    input.pluck('target', 'value')
      .subscribe(value => console.log(value));
    // "h"

    // 값을 쌍으로 뽑아내기
    input.pluck('target', 'value').pairwise()
      .subscribe(value => console.log(value));
    // ["h", "e"]

    // 중복 값 제거하기
    input.pluck('target', 'value').distinct()
      .subscribe(value => console.log(value));
    // "helo wrd"

    // 이전 값과 다를 때만 내보내기
    input.pluck('target', 'value').distinctUntilChanged()
      .subscribe(value => console.log(value));
    // "helo world"
  5. 응용프로그램(Application) 만들기
    RxJS는 코드의 오류를 줄이기에 탁월한 도구입니다.
    이에 순수함수와 상태 없는(stateless) 함수를 사용합니다.
    하지만 응용프로그램들은 상태를 가지고 있습니다(stateful).
    그렇다면 우리는 stateless한 RxJS 와 stateful한 응용프로그램을 어떻게 연결할 수 있을까요?
    0 이라는 값으로부터 단순한 상태 저장(State Store)을 만들어봅시다.
    매번 클릭할 때 마다 우리는 State Store의 값이 증가하길 원합니다.

    var button = document.querySelector('button');
    Rx.Observable.fromEvent(button, 'click')

      // 카운트의 스트림을 합산(scan-reduce)합니다.
      .scan(count => count + 1, 0)
      // 매번 그것이 변할 때 마다 요소(element)의 갯수를 설정합니다.
      .subscribe(count => document.querySelector('#count').innerHTML = count);

    이렇게 RxJS에서 상태를 만들어 보았습니다. 하지만 DOM을 변경하는 것은 마지막 줄에서 일어나는 부작용(Side-effect)입니다.
  6. 상태 저장소(State store)
    응용 프로그램에서는 상태를 유지하기를 위해 State Store를 사용합니다. 이들은 프레임워크마다 store나 reducer, model 등 각각 다른 이름으로 불립니다. 그러나 그것들은 단지 객체(Object)일 뿐입니다.

    var increaseButton = document.querySelector('#increase');
    var increase = Rx.Observable.fromEvent(increaseButton, 'click')

      // 우리는 함수에 대입하여 상태를 변하게 합니다.
      .map(() => state => Object.assign({}, state, {count: state.count + 1}));
    우리가 여기서 하는 것은 클릭 이벤트를 상태 변경 함수에 매핑 하는 것입니다.
    그래서 값을 매핑하는 것 대신 함수를 매핑하였습니다.
    함수는 State Store 의 상태를 변화시킬 것입니다.
    그러면, 실제로 어떻게 변하는지 살펴봅니다.

    var increaseButton = document.querySelector('#increase');
    var increase = Rx.Observable.fromEvent(increaseButton, 'click')
      .map(() => state => Object.assign({}, state, {count: state.count + 1}));

    // 우리는 초기 상태를 갖는 객체를 만들었습니다. 새로운 상태 변화가 있을 때 마다
    이를 불러내고 상태를 전달합니다.
    // 새로운 상태를 반환하고 다음 클릭에 대해 변경할 준비를 합니다.
    var state = increase.scan((state, changeFn) => changeFn(state), {count: 0});
    우리는 이제 같은 State store를 변경할 더 많은 Observables 를 추가할 수 있습니다.

    var increaseButton = document.querySelector('#increase');
    var increase = Rx.Observable.fromEvent(increaseButton, 'click')

      // 카운트를 증가시키는 함수를 매핑합니다.
      .map(() => state => Object.assign({}, state, {count: state.count + 1}));

    var decreaseButton = document.querySelector('#decrease');
    var decrease = Rx.Observable.fromEvent(decreaseButton, 'click')

      // 또한 카운트를 감소시키는 함수도 매핑합니다.
      .map(() => state => Object.assign({}, state, {count: state.count - 1}));

    var inputElement = document.querySelector('#input');
    var input = Rx.Observable.fromEvent(inputElement, 'keypress')
      // keypress 이벤트로 inpupValue 상태를 만듭니다.
      .map(event => state => Object.assign({}, state, {inputValue: event.target.value}));

    // 이 세가지 상태를 생성하는 Observables들을 병합(Merge)합니다.
    var state = Rx.Observable.merge(
      increase,
      decrease,
      input
    ).scan((state, changeFn) => changeFn(state), {
      count: 0,
      inputValue: ''
    });

    // 상태 변화에 대해 subscribe 하고 DOM을 갱신합니다.
    state.subscribe((state) => {
      document.querySelector('#count').innerHTML = state.count;
      document.querySelector('#hello').innerHTML = 'Hello ' + state.inputValue;
    });


    // 실제로 상태가 바뀌었을 때를 확인하여 렌더링을 최적화합니다.
    var prevState = {};
    state.subscribe((state) => {
      if (state.count !== prevState.count) {
        document.querySelector('#count').innerHTML = state.count;
      }
      if (state.inputValue !== prevState.inputValue) {
        document.querySelector('#hello').innerHTML = 'Hello ' + state.inputValue;
      }
      prevState = state;
    });
원문에는 immutable JS 나 React 와 같이 실제로 응용프로그램 차원에 적용하는 법도 있지만 이 글에선 범위 밖이라 다루지 않습니다.
각자 자신이 사용하는 환경에 맞게 적용해봅시다.

2016년 10월 17일 월요일

JavascriptCore in Swift 3 연습

//: Playground - noun: a place where people can play

import UIKit
import JavaScriptCore

/* swift to javascript */
let str = "var double=function(x) { return x*2 };"
let context = JSContext()

context?.evaluateScript(str)
let getDouble = context?.objectForKeyedSubscript("double")
getDouble?.call(withArguments: [1]).toString()

*2를 하는 double이라는 function을 js에서 만들고 swift에서 인지 1을 넣어 2를 반환하는 예.
스위프트에서 자바스크립트 함수를 호출할 때는 
  1. objectForKeyedSubscript를 사용하여 함수명을 지정하고
  2. call(withArguments: [, ...]) 를 사용하여 인자를 지정한다.
  3. 결과값은 JSValue 형이므로 적당히 변환해서 사용한다.

/* javascript to swfit */
let str2 = "postMessage('갔다가 다시 올꺼야')"
let postMessageBlock : @convention(block) (AnyObject?) -> (AnyObject) = { (data) in
    print(data)
    return data!
}
context?.globalObject.setValue(unsafeBitCast(postMessageBlock, to: AnyObject.self), forProperty: "postMessage")

context?.evaluateScript(str2)

반대의 경우, 즉 자바스크립트에서 스위프트의 특정 함수를 호출하고자 할 땐
해당 context의 globalObject에 setValue를 하되 unsafeBitCast를 사용한다.
evaluateScript를 한 후 js의 postMessage는 setValue가 연결한 swift쪽의 postMessageBlock을 호출.
들어온 값은 콘솔에 출력하고 자기 자신을 그대로 반환하도록 하였다.

요정도만 있으면 일단 Javascript기반 script 엔진을 만드는데 문제는 없어보인다.

Android의 경우 https://github.com/ericwlange/AndroidJSCore 를 사용 중인데

아주 좋은 예제가 있으니 이쪽을 참조하자.

* 10/25 추가분 *
Object안에 function이 있을 경우 objectForKeyedSubscript로 접근이 안되는데
context?.objectForKeyedSubscript("objS.s")
가령 이런 건 의도대로 잘 되지 않는다.

context?.evaluateScript("var someObj = { a: 1, b: 2, c: function(v) { return v*v; } }")
context?.evaluateScript("someObj.c").call(withArguments: [10]).toInt32()

이와 같이 해당 key를 evaluateScript해서 직접 call을 사용하면 접근할 수 있다.
그런데 이런 경우 문제는 단지 function(v) { return v*v; } 만 가져오는 것이므로 function 안에서 다른 멤버변수인 a,b를 접근할 수 없다.

* 10/28 추가분 *
만일 자바스크립트 쪽에서 인자로 무기명 함수를 사용할 경우 해당 인자를 JSValue로 받아 evaluateScript 하는 형식으로 사용할 수 있다.
다만 해당 함수는 바로 사용할 수 없으므로 IIFE(https://en.wikipedia.org/wiki/Immediately-invoked_function_expression)로 감싸서 바로 실행할 수 있도록 만들어 줘야한다.
let publishBlock: @convention(block) (AnyObject?, JSValue?) -> (AnyObject) = { (data, callback) in
    print("(\(callback!.toString()!))()")
    return (context?.evaluateScript(callback?.toString()))!
}
context?.globalObject.setValue(unsafeBitCast(publishBlock, to: AnyObject.self), forProperty: "Meteor_publish")
context?.evaluateScript("var q=0; Meteor_publish('something', function() { q= 100; })")
context?.evaluateScript("q")


2016년 10월 14일 금요일

ESP32 DevBoard 개봉기

오늘 드디어 손에 넣었다. ESP32 DevBoard!
Adafruit 에서 15개 한정 재입고 트윗을 보고 광속 결제.
그리고 1주일의 기다림. 사랑해요 USPS <3
알리를 이용하다보니 1주일 정도는 광속 배송임.
물론 배송비도 무자비함 -_ㅜ
15개 한정판 adafruit 발 dev board

그놈이 틀림없으렸다.

오오 강려크한 포스

ESP32_Core_board_V2라고 적혀있군요.

ESP32 맞구요. 네네.
ESP32-D0WDQ6 라고 써있는데
D → Dual-core
0 → No internal flash
W → Wi-Fi
D → Dual-mode Bluetooth
Q → Quad Flat No-leads (QFN) package
6 → 6 mm × 6 mm package body size
라고 함.

길이는 이정도

모듈크기는 이정도

코어는 6mm밖에 안해!
여기에 전기만 넣으면 BLE+WIFI!
밑에 크고 발 8개 달린 놈은 FM25Q32라고 32Mbit 플래시메모리

ESP8266 DevBoard 동생이랑 비교
크고 아름다운 레귤레이터랑 CP2102 USB Driver가 붙어있음.
ESP8266 DevBoard엔 CH340G 인데 확 작아졌네.

머리를 맞대어 보았음.
모듈크기는 아주 약간 ESP32가 더 큰데 워낙에 핀이 많고 촘촘함.
ESP8266인 ESP12는 핀 간격이 2.00mm인데 비해
ESP32는 1.27mm 밖에 안함.
딱봐도 비교가 될 정도.
크고 아름다운 Pinouts


ESP8266 보드랑 별로 안달라보인다.
http://www.silabs.com/products/mcu/pages/usbtouartbridgevcpdrivers.aspx#mac
에서 CP2102 드라이버를 설치하고
screen 으로 연결해보자.
내 경우엔 tty.SLAB_USBtoUART 로 잡혔다.
어디서 기본 속도가 115200bps 라고 들은 적이 있어서
screen /dev/tty.SLAB_USBtoUART 115200
로 접속.

:>
프롬프트가 생소하다.
보드 정보를 보기 위해 reset을 해보니
:>ets Jun  8 2016 00:22:57
rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
ets Jun  8 2016 00:22:57
rst:0x10 (RTCWDT_RTC_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0x00
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DOUT, clock div:2
load:0x3ffc0000,len:0
load:0x3ffc0000,len:2304
load:0x40078000,len:3788
ho 0 tail 12 room 4
load:0x40098000,len:532
entry 0x4009813c
;36m
m;36m**************************************
m;36m*       hello espressif ESP32!       *
m;36m*        2nd boot is running!        *
m;36m*            version (V0.1)          *
m;36m**************************************
m;36mcompile time 18:16:58
m;36m  SPI Speed      : 40MHz
m;36m  SPI Mode       : DOUT
m;36m  SPI Flash Size : 4MB
m;36mPartition Table:
m;36m## Label            Usage          Type ST Offset   Length
m;36m 0 factory          factory app      00 00 00010000 00100000
m;36m 1 rfdata           RF data          01 01 00110000 00040000
m;36m 2 wifidata         WiFi data        01 02 00150000 00040000
m;36mEnd of partition table
m;36mLoading app partition at offset 00010000
m;36msection 0: paddr=0x00000020 vaddr=0x00000000 size=0x0ffe8 ( 65512)
m;36msection 1: paddr=0x00010010 vaddr=0x3f400010 size=0x05b64 ( 23396) map
m;36msection 2: paddr=0x00015b7c vaddr=0x3ffba720 size=0x01378 (  4984) load
m;36msection 3: paddr=0x00016efc vaddr=0x40080000 size=0x00400 (  1024) load
m;36msection 4: paddr=0x00017304 vaddr=0x40080400 size=0x126ac ( 75436) load
m;36msection 5: paddr=0x000299b8 vaddr=0x00000000 size=0x06658 ( 26200)
m;36msection 6: paddr=0x00030018 vaddr=0x400d0018 size=0x325b4 (206260) map
m;36mstart: 0x400807ac
mInitializing heap allocator:
Region 19: 3FFBBA98 len 00024568 tag 0
Region 25: 3FFE8000 len 00018000 tag 1
Pro cpu up.
Pro cpu start user code
nvs_flash_init
frc2_timer_task_hdl:3ffbc564, prio:22, stack:2048
tcpip_task_hdlxxx : 3ffbeca8, prio:20,stack:2048
phy_version: 80, Aug 26 2016, 13:04:06, 0
pp_task_hdl : 3ffc34f0, prio:23, stack:8192
:>enter uart init
uart init wait fifo succeed
exit uart init
IDF version : master(db93bceb)
WIFI LIB version : master(934d079b)
ssc version : master(r283 4d376412)
!!!ready!!!
mode : softAP(26:0a:c4:00:03:98)
dhcp server start:(ip: 192.168.4.1, mask: 255.255.255.0, gw: 192.168.4.1)
+WIFI:AP_START
막막 칼라로 나온다.

쭉 보니까 여러가지 정보가 나오네
WIFI 를 보니

잘 잡힘.
신호도 양호.
BLE는 어떻게 하는지 잘 모르겠음.

help 라고 쳐보니 (?를 쳐도 같음)
:>
supported command:

Please refer to document ssc_commands.xlsx for detail
이렇게 나옴.
막상 ssc_commands.xlsx는 어디에?? 문서도 없고 검색도 안됨.

관전포인트

  1. 핀 간격이 1.27mm. 수작업으로 와이어링을 하기엔 다소 힘들것으로 보임
  2. NODEMCU 는 아직 미대응. esp-idf 가 플래싱을 포함한 이것저것 들어있는 툴.
  3. ESP8266시리즈처럼 AT 커맨드 셋이 아님. 아직 정확한 자료 없음.
  4. http://espressif.com/products/hardware/esp32/resources 관련 도구/문서들
  5. 기타 자세한 장치 스펙은 https://github.com/sparkfun/ESP32_Miscellany/blob/master/Documentation/ESP32_Specifications_EN_v1.pdf
  6. Getting Started : https://github.com/CHERTS/esp32-devkit/blob/master/Espressif/docs/ESP32/ESP32%20Getting%20Started%20Guide%20for%20SDK%20based%20on%20FreeRTOS.pdf

적다보니 Getting Started 문서 15페이지 부터 SSC 커맨드가 있음.
<명령어> -<플래그> <인자> 순의 조합.
-Q는 공통으로 Query(조회) -S는 Set(설정)이다.
-o 옵션은 1일때 STA, 2일때 AP, 3일때 둘 다

  1. op : wifi 모드 조회/설정
    1. op -Q
    2. op -S -o <mode>
  2. sta: station 모드 조회/설정
    1. sta -S -s <ssid> -b <bssid> -n <channel> -h
      sta -S 만 하면 전체 AP 조회
      -h는 hidden ssid 조회
    2. sta -Q 상태조회
    3. sta -C -s <ssid> -p <password> : AP연결
    4. sta -D : AP Disconnect
  3. ap: ap 모드 조회/설정
    1. ap -S -s <ssid> -p <password> -t encrypt -n <channel> -h -m <max_sta>
      1. -s ssid : SSID
      2. -p password : 암호
      3. -t encrypt 있으면 암호화
      4. -h : ssid 숨김
      5. -n channel : channel
      6. -m max_sta : 최대 접근 가능한 station 갯수
    2. ap -Q : 조회
    3. ap -L : MAC/IP Address 조회
  4. mac: mac 조회 -Q -o 를 사용하되 mode는 1,2만 있다.
    1. mac -Q -o 1 : STA MAC 정보
    2. mac -Q -o 2 : AP MAC 정보
  5. dhcp: mac 조회/설정
    1. dhcp -S -o mode : DHCP 시작
    2. dhcp -E -o mode : DHCP 종료
  6. ip: mac 조회/설정
    1. -Q -o 1 : STA IP정보
    2. -Q -o 2 : AP IP정보
    3. -Q -o 3 : STA & AP IP 정보
    4. -S -i <ip> -o <mode> -m <mask> -g <gateway> : IP 설정 -o는 1,2,3과 같다.
  7. reboot: 말그대로 reboot
  8. ram: heap size 반환
일단 여기까지만 나와있음. 음? BLE는? 그리고 설정밖에 없네??
BSSID로 scan은 가능하지만 접속은 안되네
한번 sta로 접속을 시도해본다. -s 에 SSID, -p에 암호를 각각 넣어서 시도.
:>sta -C -s XXXXXX -p QQQQQQ
+JAP:OK
:>n:11 0, o:1 0, ap:255 255, sta:11 0, prof:1n:11 0, o:11 0, ap:255 255, sta:11 0, prof:1state: 0 -> 2 (b0)stastate: 2 -> 3 (0)state: 3 -> 5 (10)add 0

:>
+JAP:WIFICONNECTED
:>ip: 192.168.0.47, mask: 255.255.255.0, gw: 192.168.0.1
+JAP:CONNECTED,AccessDenied
:>sta -Q
+JAP:CONNECTED,AccessDenied
:>
해보니까 scan 찾고 접속하는 건 잘된다.
ip도 조회해 본다.
:>ip -Q -o 1
+STAIP:192.168.0.47
+STAIPMASK:255.255.255.0
+STAIPGW:192.168.0.1
기분탓인지 모르겠지만 ESP8266보다 훨씬 빠르게 느껴진다. 응답이든 뭐든.

시간 날때 build 도전.