Node.js Game Server Framework & Development Architecture

몇 년 전, 브렛 로슨은 훌륭한 블로그 시리즈 에서 게임 서버 프레임워크 개발을 위해 Couchbase Server와 Node.js를 사용하는 방법에 대해 설명했습니다. 그 이후로 Couchbase용 Node.js SDK는 버전 1.x에서 2.x로 크게 성장했습니다.

이 글에서는 원래 세 개의 게시물을 다시 살펴보고 최신 Node.js 및 Express 프레임워크 표준과 최신 Node.js SDK 버전의 Couchbase에 맞게 변경해 보려고 합니다.

전제 조건

Node.js 0.12
카우치베이스 서버 4.0

프로젝트 준비하기

Mac, Windows 또는 Linux를 사용하든 새 Express 프레임워크 애플리케이션을 만들면 이들 간에 일관성이 유지되어야 합니다. 라는 새 디렉터리를 만듭니다. gameapi-nodejs 데스크톱의 터미널(Mac/Linux) 또는 명령 프롬프트(Windows)에서 다음 명령을 실행합니다:


npm init

npm init

묻는 질문에 최선을 다해 답하세요. 물론 명령 프롬프트 또는 터미널에서 프로젝트 디렉터리가 현재 디렉터리여야 성공할 수 있습니다. 명령 대신 이 파일을 수동으로 만들어 채울 수도 있습니다. 프로젝트 디렉터리에 package.json이라는 새 파일을 만들고 다음을 채웁니다:


{
  "name": "gameapi-nodejs",
  "version": "1.0.0",
  "description": "An example of using the Node.js SDK for Couchbase to create a simple game server",
  "author": "Couchbase, Inc.",
  "license": "MIT"
}

{

"name": "gameapi-nodejs",

"버전": "1.0.0",

"설명": "카우치베이스용 Node.js SDK를 사용하여 간단한 게임 서버를 만드는 예제",

"author": "Couchbase, Inc.",

"라이선스": "MIT"

}

아직 끝나지 않았습니다. 이 애플리케이션을 계획하기 전에 프로젝트 종속성을 설치해야 합니다. 명령 프롬프트 또는 터미널에서 다음 명령을 실행합니다:


npm install body-parser couchbase express node-forge uuid --save

npm 설치 body-파서 카우치베이스 express 노드-포지 uuid --저장

이렇게 하면 Express 프레임워크, Couchbase Node.js SDK, 비밀번호 해싱을 위한 Forge, 고유 값 생성을 위한 UUID, URL 인코딩 및 JSON POST 데이터를 처리하기 위한 본문 파서 미들웨어가 설치됩니다.

데이터베이스 준비하기

코딩을 시작하기 전에 다음과 같은 버킷이 있는 Couchbase Server를 설치해야 합니다. 게임 샘플 생성되었습니다.

이 프로젝트는 Couchbase 4.0의 주요 기능을 사용할 예정이므로 기본 인덱스가 생성되도록 버킷을 추가로 구성해야 합니다. Linux, Mac 또는 Windows 시스템을 사용하는 경우, 이 작업은 Couchbase 쿼리(CBQ) 클라이언트를 통해 쉽게 수행할 수 있습니다.

Mac

Mac에서 CBQ를 열려면 터미널에서 다음을 실행합니다:


./Applications/Couchbase Server.app/Contents/Resources/couchbase-core/bin/cbq

./애플리케이션/카우치베이스 서버.앱/콘텐츠/리소스/카우치베이스-핵심/bin/cbq

Windows

Windows에서 CBQ를 열려면 명령 프롬프트에서 다음을 실행합니다:


C:/Program Files/Couchbase/Server/bin/cbq.exe

C:/프로그램 파일/카우치베이스/서버/bin/cbq.exe

기본 색인 만들기

CBQ를 연 상태에서 다음을 실행합니다:


CREATE PRIMARY INDEX ON `gaming-sample` using GSI;

만들기 기본 INDEX 켜기 `게임-샘플` 사용 GSI;

이제 버킷을 나머지 프로젝트에 사용할 준비가 되었습니다!

프로젝트 구조

프로젝트는 다음과 같이 구성될 예정입니다:

항목	부모	설명
모델		모든 데이터베이스 클래스 파일은 여기로 이동합니다.
경로		모든 API 엔드포인트 정의는 여기로 이동합니다.
accountmodel.js	모델	계정 정보 생성 및 검색
세션모델.js	모델	사용자 인증 및 세션 정보 유지 관리하기
statemodel.js	모델	게임 상태 정보 생성, 업데이트 및 검색
routes.js	경로	GET, POST, PUT의 모든 엔드포인트가 여기에 있습니다.
app.js		서버 설정 정보
config.json		정적 변수
package.json		종속성 정보

기본 사항

Node.js 게임 서버 로직에 대해 자세히 알아보기 전에 기본 Express 프레임워크 애플리케이션을 구성하는 것이 가장 좋습니다.

프로젝트 루트에서 다음과 같은 파일을 만들고 엽니다. config.json 에 Couchbase 연결 정보와 같은 정적 정보를 보관할 수 있습니다. 열리면 다음을 포함하세요:


{
    "couchbase": {
        "server": "127.0.0.1:8091",
        "bucket": "gaming-sample"
    }
}

{

"couchbase": {

"서버": "127.0.0.1:8091",

"bucket": "gaming-sample"

}

프로젝트 루트에서 다음과 같은 파일을 만들고 엽니다. app.js 파일에는 Node.js 서버 실행에 대한 모든 기본 정보가 들어 있습니다. 파일을 열면 다음을 포함하세요:


var express = require("express");
var bodyParser = require("body-parser");
var couchbase = require("couchbase");
var config = require("./config");
var app = express();

app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));

// Global declaration of the Couchbase server and bucket to be used
module.exports.bucket = (new couchbase.Cluster(config.couchbase.server)).openBucket(config.couchbase.bucket);

// All endpoints to be used in this application
var routes = require("./routes/routes.js")(app);

var server = app.listen(3000, function () {
    console.log("Listening on port %s...", server.address().port);
});

var express = require("express");

var bodyParser = require("body-parser");

var 카우치베이스 = require("couchbase");

var 구성 = require("./config");

var 앱 = express();

앱.사용(bodyParser.json());

앱.사용(bodyParser.urlencoded({ 확장: true }));

// 사용할 카우치베이스 서버 및 버킷의 글로벌 선언

모듈.수출.버킷 = (new 카우치베이스.클러스터(구성.카우치베이스.서버)).오픈버킷(구성.카우치베이스.버킷);

// 이 애플리케이션에서 사용할 모든 엔드포인트

var 경로 = require("./routes/routes.js")(앱);

var 서버 = 앱.듣기(3000, 함수 () {

콘솔.로그("포트 %s에서 수신 중...", 서버.주소().포트);

});

여기에 표시되는 내용을 분석해 보겠습니다. 처음 몇 줄은 애플리케이션에 종속성을 포함하는 것입니다. 특별한 것은 없습니다. 중요한 것은 다음과 같습니다:


app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));

앱.사용(bodyParser.json());

앱.사용(bodyParser.urlencoded({ 확장: true }));

즉, 요청 본문에서 JSON 데이터와 URL로 인코딩된 데이터를 파싱하게 됩니다. 특히 POST 및 PUT 요청이 그렇습니다. 다음으로 할 일은 애플리케이션에서 Couchbase 클러스터를 초기화하고 애플리케이션 내에서 사용할 단일 버킷을 여는 것입니다:


module.exports.bucket = (new couchbase.Cluster(config.couchbase.server)).openBucket(config.couchbase.bucket);

모듈.수출.버킷 = (new 카우치베이스.클러스터(구성.카우치베이스.서버)).오픈버킷(구성.카우치베이스.버킷);

다음을 포함합니다. module.exports.bucket 애플리케이션을 통해 사용한다는 의미입니다. 이제 다른 자바스크립트 파일에서 버킷에 액세스하려면 그냥 하면 됩니다:


var bucket = require("relative/path/to/app").bucket;

var 버킷 = require("상대/경로/투/앱").버킷;

다음에는 곧 생성될 예정인 routes/routes.js 파일을 전달하고 앱 변수를 인수 중 하나로 사용할 수 있습니다. 이것이 무엇을 하는지는 곧 분명해질 것입니다.

마지막으로 app.listen 포트 3000에서 요청을 수신 대기하도록 Node.js에 지시하고 있습니다. 애플리케이션은 가장 기본적인 상태에서 거의 사용할 수 있습니다. 생성 및 열기 routes/routes.js 를 클릭하고 다음 줄을 추가합니다:


var appRouter = function(app) {

    app.get("/", function(req, res) {
        res.status(403).send("Not a valid endpoint");
    });

}

module.exports = appRouter;

var 앱라우터 = 함수(앱) {

앱.get("/", 함수(req, res) {

res.상태(403).보내기("유효한 엔드포인트가 아님");

});

}

모듈.수출 = 앱라우터;

이제 다음을 실행하여 애플리케이션을 실행할 수 있습니다. 노드 app.js 명령 프롬프트 또는 터미널에서 입력합니다. 착륙 위치 http://localhost:3000 를 실행하면 "유효한 엔드포인트가 아닙니다"라는 메시지가 표시됩니다.

API 데이터 모델

중요한 코드를 살펴보기 전에 Couchbase에서 데이터가 어떻게 보이는지 아는 것이 가장 좋습니다. 한 사용자에게는 다음과 같이 보이는 4개의 문서가 있습니다:

사용자 문서

사용자 문서에는 사용자에 대한 모든 정보가 저장됩니다. 이 애플리케이션의 경우 해당 정보는 이름, 사용자 이름, 비밀번호입니다.
이 문서의 이름 앞에 다음과 같은 접두사가 붙습니다. user:: 에 고유한 UID 값을 추가합니다. 이 문서 이름 지정 전략은 복합 키라는 것을 사용합니다.


{
    "type": "user",
    "uid", "",
    "name": "",
    "username": "",
    "password": ""
}

{

"type": "user",

"uid", "",

"name": "",

"username": "",

"비밀번호": ""

}

사용자 이름 문서

사용자명 문서에는 사용자 문서에 있는 uid 값만 저장됩니다. 사용자명 문서의 목적은 로그인 방법 문서처럼 생각할 수 있습니다. 예를 들어 사용자가 사용자 이름과 비밀번호를 입력하는 간단한 로그인을 나타낼 수 있습니다. 이 문서에는 연결 UID가 포함되어 있기 때문에 사용자 문서에 연결될 수 있습니다. 사용자 이름 문서 앞에는 사용자 이름:: 을 입력하면 실제 사용자 아이디가 추가됩니다. 페이스북이나 트위터를 로그인 수단으로 사용하고 아이디 필드를 통해 연결하는 경우에도 비슷한 전략을 사용할 수 있습니다.


{
    "type": "username",
    "uid": ""
}

{

"type": "username",

"uid": ""

}

세션 문서

세션 문서는 자동 만료되는 문서로, 사용자가 보다 안전한 정보로 이동하는 경로 역할을 합니다. 이론상으로는 사용자 프런트엔드에서 시드 값을 저장하여 보호된 엔드포인트 간에 전달합니다. 이를 통해 사용자에게 연결된 UID에 액세스할 수 있습니다.


{
    "type": "session",
    "sid": "",
    "uid": ""
}

{

"type": "세션",

"sid": "",

"uid": ""

}

상태 문서

상태 문서에는 게임의 특정 상태에 대한 정보가 저장됩니다. 예를 들어 게임 캐릭터의 생명력이 5개, 물약이 20개 남은 경우 해당 정보가 여기에 저장됩니다. 두 개의 활성 게임 세션이 같은 계정으로 저장되는 것을 방지하기 위한 버전 정보도 있습니다.


{
    "type": "state",
    "uid": "",
    "states": {
        "state-name": {
            "version": 1,
            "data": { }
        }
    }
}

{

"type": "state",

"uid": "",

"states": {

"state-name": {

"버전": 1,

"데이터": { }

}

계정 모델 만들기

계정 모델은 세 가지 특별한 용도로 사용됩니다:

사용자 계정 만들기
사용자 계정 복구하기
해시된 비밀번호와 해시되지 않은 비밀번호 비교하기

코딩을 시작하기 전에 인클루드를 순서대로 정리해야 합니다. 다음을 models/accountmodel.js file:


var uuid = require("uuid");
var forge = require("node-forge");
var db = require("../app").bucket;
var N1qlQuery = require('couchbase').N1qlQuery;

var uuid = require("uuid");

var 포지 = require("node-forge");

var db = require("../app").버킷;

var N1qlQuery = require('couchbase').N1qlQuery;

위에서 본 데이터 모델에 따라 사용자 계정을 만들려면 이름, 사용자 아이디, 비밀번호가 필요합니다. 이 정보가 준비되면 비밀번호는 해시되고 사용자 정보는 다음과 같이 참조 문서와 함께 저장됩니다:


AccountModel.create = function(params, callback) {
    var userDoc = {
        type: "user",
        uid: uuid.v4(),
        name: params.name,
        username: params.username,
        password: forge.md.sha1.create().update(params.password).digest().toHex()
    };
    var referenceDoc = {
        type: "username",
        uid: userDoc.uid
    };
    db.insert("username::" + userDoc.username, referenceDoc, function(error) {
        if(error) {
            callback(error, null);
            return;
        }
        db.insert("user::" + userDoc.uid, userDoc, function(error, result) {
            if(error) {
                callback(error, null);
                return;
            }
            callback(null, {message: "success", data: result});
        });
    });
};

계정 모델.create = 함수(매개변수, 콜백) {

var 사용자 문서 = {

유형: "user",

uid: uuid.v4(),

이름: 매개변수.이름,

사용자 이름: 매개변수.사용자 이름,

비밀번호: 포지.md.sha1.create().업데이트(매개변수.비밀번호).다이제스트().toHex()

};

var 참조 문서 = {

유형: "username",

uid: 사용자 문서.uid

};

db.삽입("사용자 이름::" + 사용자 문서.사용자 이름, 참조 문서, 함수(오류) {

만약(오류) {

콜백(오류, null);

반환;

}

db.삽입("user::" + 사용자 문서.uid, 사용자 문서, 함수(오류, 결과) {

만약(오류) {

콜백(오류, null);

반환;

}

콜백(null, {메시지: "성공", 데이터: 결과});

});

};

위 코드에서 먼저 새 참조 문서를 삽입하려고 시도합니다. 실패하면(이미 존재하는 문서일 수도 있음) 두 문서 모두 저장되지 않고 대신 오류 메시지가 반환됩니다. 성공 또는 실패 여부에 관계없이 라우팅 파일의 콜백이 실행되어 요청자에게 어떤 종류의 답변이든 표시합니다.

사용자 데이터를 읽을 때 두 가지 중 하나가 발생할 수 있습니다. 일종의 간단한 로그인을 수행하기 때문에 사용자 이름을 전달하거나 사용자 ID를 전달할 수 있습니다. 목적에 따라 다릅니다. 사용자 이름으로만 로그인한다고 가정하면 다음과 같은 함수를 호출하고 싶을 것입니다:


AccountModel.getByUsername = function(params, callback) {
    var query = N1qlQuery.fromString(
        "select users.* from `gaming-sample` as usernames " +
        "join `gaming-sample` as users on keys ("user::" || usernames.uid) " +
        "where meta(usernames).id = $1"
    );
    db.query(query, ["username::" + params.username], function(error, result) {
        if(error) {
            return callback(error, null);
        }
        callback(null, result);
    });
};

계정 모델.사용자 이름 = 함수(매개변수, 콜백) {

var 쿼리 = N1qlQuery.fromString(

"`gaming-sample`에서 users.*를 사용자 이름으로 선택" +

"키의 사용자로 `gaming-sample`에 가입 ("사용자::" || usernames.uid) " +

"여기서 메타(사용자 이름).id = $1"

);

db.쿼리(쿼리, ["사용자 이름::" + 매개변수.사용자 이름], 함수(오류, 결과) {

만약(오류) {

반환 콜백(오류, null);

}

콜백(null, 결과);

});

};

Couchbase 4.0의 새로운 기능인 N1QL 쿼리를 어떻게 사용하고 있는지 주목하세요. 이 쿼리는 기존 SQL과 매우 유사하며 애플리케이션 계층에서 데이터를 크런치하거나 포맷할 필요가 없는 편리함을 제공합니다. 이 모든 작업은 Couchbase Server가 자동으로 수행합니다. 하지만 이전 버전의 Couchbase 및 기타 NoSQL 플랫폼에서와 같이 데이터를 요청할 수 있는 옵션도 있습니다.

위의 N1QL 문에서는 일반 텍스트 사용자 이름에 복합 키가 추가된 문서를 선택하고 있습니다. 사용자 이름 문서(외래 키)와 사용자 문서(기본 키)의 uid 속성을 사용하여 조인이 이루어지고 있습니다.

이제 비밀번호를 확인하는 단계로 넘어갑니다. 여기서는 데이터베이스를 호출하지 않습니다. 원시 비밀번호를 가져와서 해싱한 다음 해시를 저장된 비밀번호와 비교하기만 하면 됩니다.


AccountModel.validatePassword = function(rawPassword, hashedPassword) {
    return forge.md.sha1.create().update(rawPassword).digest().toHex() === hashedPassword ? true : false;
};

계정 모델.유효성 검사 비밀번호 = 함수(rawPassword, 해시된 비밀번호) {

반환 포지.md.sha1.create().업데이트(rawPassword).다이제스트().toHex() === 해시된 비밀번호 ? true : false;

};

만들려면 models/accountmodel.js 경로 파일에서 사용할 수 있도록 하려면 다음과 같이 내보내야 합니다.
models/accountmodel.js 코드:


module.exports = AccountModel;

모듈.수출 = 계정 모델;

세션 모델 만들기

세션 모델은 세 가지 특별한 용도로 사용됩니다:

사용자 세션 만들기
사용자 세션 다시 가져오기
사용자 세션 유효성 검사

코딩을 시작하기 전에 인클루드를 순서대로 정리해야 합니다. 다음을 models/sessionmodel.js file:


var uuid = require("uuid");
var db = require("../app").bucket;

var uuid = require("uuid");

var db = require("../app").버킷;

세션 만들기

사용자가 세션을 생성하려면 아이디를 제공해야 합니다. 이를 통해 고유한 세션 ID가 생성되고 만료와 함께 데이터베이스에 삽입됩니다. 문서가 만료되면 사용자의 개입 없이 자동으로 Couchbase에서 제거되어 사용자가 로그아웃됩니다.


SessionModel.create = function(uid, callback) {
    var sessionDoc = {
        type: "session",
        sid: uuid.v4(),
        uid: uid
    };
    db.insert("session::" + sessionDoc.sid, sessionDoc, {"expiry": 3600}, function(error, result) {
        if(error) {
            callback(error, null);
            return;
        }
        callback(null, sessionDoc.sid);
    });
};

세션 모델.create = 함수(uid, 콜백) {

var 세션 문서 = {

유형: "세션",

sid: uuid.v4(),

uid: uid

};

db.삽입("세션::" + 세션 문서.sid, 세션 문서, {"만료": 3600}, 함수(오류, 결과) {

만약(오류) {

콜백(오류, null);

반환;

}

콜백(null, 세션 문서.sid);

});

};

사용자 인증하기

사용자 세션이 생성되면 사용자가 보호된 엔드포인트에 도달할 때마다 세션 ID를 사용해야 합니다.


SessionModel.authenticate = function(req, res, next) {
    if(!req.headers.authorization) {
        next("Must be authorized to use");
    }
    var authInfo = req.headers.authorization.split(" ");
    if(authInfo[0] === "Bearer") {
        var sid = authInfo[1];
        SessionModel.get(sid, function(error, result) {
            if(error) {
                return next(error);
            }
            SessionModel.refresh(sid, function() {});
            req.uid = result.value.uid;
            next();
        });
    }
};

세션 모델.인증 = 함수(req, res, 다음) {

만약(!req.헤더.권한 부여) {

다음("사용 권한이 있어야 함");

}

var authInfo = req.헤더.권한 부여.분할(" ");

만약(authInfo[0] === "무기명") {

var sid = authInfo[1];

세션 모델.get(sid, 함수(오류, 결과) {

만약(오류) {

반환 다음(오류);

}

세션 모델.새로 고침(sid, 함수() {});

req.uid = 결과.값.uid;

다음();

});

}

};

위 코드에서 함수는 세션 ID를 받아 세션이 이미 존재하는지 조회하는 데 사용합니다. 세션이 존재하면 세션 만료 시간을 재설정하고 세션과 연결된 UID를 반환합니다. 세션 정보를 가져오는 방법은 다음과 같습니다:


SessionModel.get = function(sid, callback) {
    db.get("session::" + sid, function(error, result) {
        if(error) {
            callback(error, null);
            return;
        }
        callback(null, result);
    });
};

세션 모델.get = 함수(sid, 콜백) {

db.get("세션::" + sid, 함수(오류, 결과) {

만약(오류) {

콜백(오류, null);

반환;

}

콜백(null, 결과);

});

};

나쁘지 않죠? 마지막으로 세션 재설정도 비슷한 방식으로 이루어짐을 알 수 있습니다:


SessionModel.refresh = function(sid, callback) {
    db.touch("session::" + sid, 3600, function(error, result) {
        if(error) {
            callback(error, null);
        }
    });
};

세션 모델.새로 고침 = 함수(sid, 콜백) {

db.터치("세션::" + sid, 3600, 함수(오류, 결과) {

만약(오류) {

콜백(오류, null);

}

});

};

터치 방식은 시간을 추가하지 않고 대신 시간을 초기화합니다. 이 경우 타이머가 1시간으로 재설정됩니다.

만들려면 models/sessionmodel.js 경로 파일에서 사용할 수 있도록 하려면 다음과 같이 내보내야 합니다. models/sessionmodel.js 코드:


module.exports = SessionModel;

모듈.수출 = 세션 모델;

상태 모델 만들기

상태 모델은 두 가지 특별한 용도로 사용됩니다:

저장 상태 생성 또는 업데이트하기
이름으로 저장 상태 가져오기

코딩을 시작하기 전에 인클루드를 순서대로 정리해야 합니다. 다음을 models/statemodel.js file:


var uuid = require("uuid");
var couchbase = require("couchbase");
var N1qlQuery = require('couchbase').N1qlQuery;
var db = require("../app").bucket;

var uuid = require("uuid");

var 카우치베이스 = require("couchbase");

var N1qlQuery = require('couchbase').N1qlQuery;

var db = require("../app").버킷;

저장 상태 만들기

저장 상태를 만들거나 업데이트하는 목적은 먼저 저장 상태가 존재하는지 확인하는 것입니다. 존재하지 않으면 생성합니다. 존재한다면 존재하는 정보를 가져와서 변경한 다음 데이터베이스에 현재 존재하는 모든 정보를 대체합니다. 이 모든 작업은 게임 저장 버전 간의 충돌을 피하기 위해 상태 버전을 늘리면서 수행됩니다. 실제로 카우치베이스에 저장할 때 충돌을 방지하기 위한 것이 아니라, 두 개의 기기에서 게임을 선택해서 훨씬 오래된 저장으로 게임 데이터를 덮어쓰지 않도록 하기 위한 것입니다.


StateModel.save = function(uid, name, preVer, data, callback) {
    db.get("user::" + uid + "::state", function(error, result) {
        if(error &amp;&amp; error.code !== couchbase.errors.keyNotFound) {
            callback(error, null);
            return;
        }
        var stateDoc = {
            type: "state",
            uid: uid,
            states: {}
        };
        if(result != null &amp;&amp; result.value) {
            stateDoc = result.value;
        }
        var stateBlock = {
            version: 0,
            data: null
        };
        if(stateDoc.states[name]) {
            stateBlock = stateDoc.states[name];
        } else {
            stateDoc.states[name] = stateBlock;
        }
        if(stateBlock.version !== preVer) {
            return callback({"status": "error", "message": "Your version does not match the server version"});
        } else {
            stateBlock.version++;
            stateBlock.data = data;
        }
        var stateOptions = {};
        if(result != null &amp;&amp; result.value) {
            stateOptions.cas = result.cas;
        }
        db.upsert("user::" + uid + "::state", stateDoc, stateOptions, function(error, result) {
            if(error) {
                return callback(error, null);
            }
            callback(null, stateBlock);
        });
    });
};

StateModel.저장 = 함수(uid, 이름, preVer, 데이터, 콜백) {

db.get("user::" + uid + "::상태", 함수(오류, 결과) {

만약(오류 && 오류.코드 !== 카우치베이스.오류.keyNotFound) {

콜백(오류, null);

반환;

}

var stateDoc = {

유형: "state",

uid: uid,

상태: {}

};

만약(결과 != null && 결과.값) {

stateDoc = 결과.값;

}

var stateBlock = {

버전: 0,

데이터: null

};

만약(stateDoc.상태[이름]) {

stateBlock = stateDoc.상태[이름];

} else {

stateDoc.상태[이름] = stateBlock;

}

만약(stateBlock.버전 !== preVer) {

반환 콜백({"status": "오류", "메시지": "사용자 버전이 서버 버전과 일치하지 않습니다."});

} else {

stateBlock.버전++;

stateBlock.데이터 = 데이터;

}

var 상태 옵션 = {};

만약(결과 != null && 결과.값) {

상태 옵션.cas = 결과.cas;

}

db.업서트("user::" + uid + "::상태", stateDoc, 상태 옵션, 함수(오류, 결과) {

만약(오류) {

반환 콜백(오류, null);

}

콜백(null, stateBlock);

});

};

참조 업서트 를 입력하세요. 카우치베이스에서는 존재하지 않으면 생성하고, 존재하면 대체한다는 뜻입니다. 게임의 저장 상태와 같은 작업에 매우 편리합니다.

상태 가져오기

이렇게 하면 생성한 모든 저장 상태를 가져올 수 있습니다.


StateModel.getByUserIdAndName = function(uid, name, callback) {
    db.get("user::" + uid + "::state", function(error, result) {
        if(error) {
            if(error.code !== couchbase.errors.keyNotFound) {
                return callback(null, {});
            } else {
                return callback(error, null);
            }
        }
        if(!result.value.states[name]) {
            return callback({"status": "error", "message": "State does not exist"}, null);
        }
        callback(null, result.value.states[name]);
    });
};

StateModel.getByUserIdAndName = 함수(uid, 이름, 콜백) {

db.get("user::" + uid + "::상태", 함수(오류, 결과) {

만약(오류) {

만약(오류.코드 !== 카우치베이스.오류.keyNotFound) {

반환 콜백(null, {});

} else {

반환 콜백(오류, null);

}

만약(!결과.값.상태[이름]) {

반환 콜백({"status": "오류", "메시지": "상태가 존재하지 않음"}, null);

}

콜백(null, 결과.값.상태[이름]);

});

};

이 개념은 사용자 ID를 기반으로 문서 조회를 수행한다는 것입니다. 특정 아이디에 대한 상태 문서가 존재하면 연관 배열에서 조회를 수행하여 상태 이름이 존재하는지 확인합니다. 존재한다면 그 이름에 대해 존재하는 모든 상태 콘텐츠를 반환합니다.

만들려면 models/statemodel.js 경로 파일에서 사용할 수 있도록 하려면 다음과 같이 내보내야 합니다. models/statemodel.js 코드:


module.exports = StateModel;

모듈.수출 = StateModel;

API 경로 만들기

위에서 필요한 모든 데이터 모델을 만들었으므로 이제 이를 사용자가 액세스할 수 있는 경로와 함께 연결할 차례입니다. 다시 routes/routes.js 파일에 계정 모델 경로를 추가하는 것부터 시작하겠습니다:


app.post("/api/user", function(req, res) {
    if(!req.body.name) {
        return res.status(400).send({"status": "error", "message": "A name is required"});
    } else if(!req.body.username) {
        return res.status(400).send({"status": "error", "message": "A username is required"});
    } else if(!req.body.password) {
        return res.status(400).send({"status": "error", "message": "A password is required"});
    }
    AccountModel.create(req.body, function(error, result) {
        if(error) {
            return res.status(400).send(error);
        }
        res.send(result);
    });
});

앱.post("/api/user", 함수(req, res) {

만약(!req.body.이름) {

반환 res.상태(400).보내기({"status": "오류", "메시지": "이름이 필요합니다"});

} else 만약(!req.body.사용자 이름) {

반환 res.상태(400).보내기({"status": "오류", "메시지": "사용자 이름이 필요합니다."});

} else 만약(!req.body.비밀번호) {

반환 res.상태(400).보내기({"status": "오류", "메시지": "비밀번호가 필요합니다."});

}

계정 모델.create(req.body, 함수(오류, 결과) {

만약(오류) {

반환 res.상태(400).보내기(오류);

}

res.보내기(결과);

});

위의 엔드포인트는 이름, 사용자 이름, 비밀번호 본문 매개변수가 포함된 POST 요청을 기대합니다. HTTP 요청을 통해 데이터를 생성하거나 삽입할 때 POST를 사용하는 것이 가장 좋은 방법이기 때문에 POST를 수신 대기하고 있습니다. 이 세 가지가 모두 존재하면 AccountModel.create() 메서드가 호출되어 메서드의 성공 여부에 따라 오류 또는 결과를 반환합니다. 필수 매개변수 중 하나 이상이 존재하지 않으면 오류가 반환됩니다. 오류 코드 목록은 다음과 같습니다. 여기.

이 예제에서는 사용자 정보를 가져오기 위한 엔드포인트는 그다지 중요하지 않으므로 사용자 인증과 세션 생성으로 바로 넘어가겠습니다. 이 예제에서는 routes/routes.js 파일에 다음을 추가합니다:


app.get("/api/auth", function(req, res, next) {
    if(!req.query.username) {
        return next(JSON.stringify({"status": "error", "message": "A username must be provided"}));
    }
    if(!req.query.password) {
        return next(JSON.stringify({"status": "error", "message": "A password must be provided"}));
    }
    AccountModel.getByUsername(req.query, function(error, user) {
        if(error) {
            return res.status(400).send(error);
        }
        if(!AccountModel.validatePassword(req.query.password, user[0].password)) {
            return res.send({"status": "error", "message": "The password entered is invalid"});
        }
        SessionModel.create(user[0].uid, function(error, result) {
            if(error) {
                return res.status(400).send(error);
            }
            res.setHeader("Authorization", "Bearer " + result);
            res.send(user);
        });
    });
});

앱.get("/api/auth", 함수(req, res, 다음) {

만약(!req.쿼리.사용자 이름) {

반환 다음(JSON.문자열화({"status": "오류", "메시지": "사용자 아이디를 입력해야 합니다."}));

}

만약(!req.쿼리.비밀번호) {

반환 다음(JSON.문자열화({"status": "오류", "메시지": "비밀번호를 입력해야 합니다"}));

}

계정 모델.사용자 이름(req.쿼리, 함수(오류, 사용자) {

만약(오류) {

반환 res.상태(400).보내기(오류);

}

만약(!계정 모델.유효성 검사 비밀번호(req.쿼리.비밀번호, 사용자[0].비밀번호)) {

반환 res.보내기({"status": "오류", "메시지": "입력한 비밀번호가 유효하지 않습니다."});

}

세션 모델.create(사용자[0].uid, 함수(오류, 결과) {

만약(오류) {

반환 res.상태(400).보내기(오류);

}

res.setHeader("권한 부여", "무기명 " + 결과);

res.보내기(사용자);

});

인증 엔드포인트는 사용자 이름과 비밀번호를 요구합니다. 두 가지가 모두 발견되면 사용자를 조회합니다. 사용자를 찾으면 비밀번호 비교가 이루어지고 성공하면 세션이 생성됩니다.

마지막으로 유용한 두 가지 API 엔드포인트는 저장 상태를 가져오고 생성하는 데 사용됩니다. 저장 상태 엔드포인트를 만드는 것부터 시작해서, 여러분의 routes/routes.js를 클릭하고 다음을 추가합니다:


app.put("/api/state/:name", SessionModel.authenticate, function(req, res, next) {
    StateModel.save(req.uid, req.params.name, parseInt(req.query.preVer, 10), req.body, function(error, result) {
        if(error) {
            return res.send(error);
        }
        res.send(result);
    });
});

앱.put("/api/state/:name", 세션 모델.인증, 함수(req, res, 다음) {

StateModel.저장(req.uid, req.매개변수.이름, parseInt(req.쿼리.preVer, 10), req.body, 함수(오류, 결과) {

만약(오류) {

반환 res.보내기(오류);

}

res.보내기(결과);

});

위의 엔드포인트는 상태 이름을 나타내는 URL 파라미터, 현재 상태 버전을 나타내는 쿼리 파라미터, 저장할 가치가 있는 게임 데이터를 나타내므로 상상할 수 있는 모든 JSON을 포함할 수 있는 요청 본문을 기대합니다.

마지막으로 저장된 상태를 가져오는 작업만 남았습니다.


app.get("/api/state/:name", SessionModel.authenticate, function(req, res, next) {
    StateModel.getByUserIdAndName(req.uid, req.params.name, function(error, result) {
        if(error) {
            return res.send(error);
        }
        res.send(result);
    });
});

앱.get("/api/state/:name", 세션 모델.인증, 함수(req, res, 다음) {

StateModel.getByUserIdAndName(req.uid, req.매개변수.이름, 함수(오류, 결과) {

만약(오류) {

반환 res.보내기(오류);

}

res.보내기(결과);

});

위의 엔드포인트는 특정 저장 상태를 나타내는 URL 매개변수를 찾을 것으로 예상합니다. 물론 사용자가 먼저 인증되기를 기대합니다.

API 테스트

에서 만든 API 엔드포인트는 routes/routes.js 파일은 몇 가지 방법으로 테스트할 수 있습니다. 제가 가장 좋아하는 두 가지 테스트 방법은 Chrome용 Postman 확장 프로그램 또는 cURL을 사용하는 것입니다. cURL을 사용하여 직접 테스트해 보세요:


curl -X POST http://localhost:3000/api/user --data "name=Nic%20Raboy&amp;username=nraboy&amp;password=12345"

RESPONSE:

{
    "message": "success",
    "data": {
        "cas": "16588775686144"
    }
}

curl -X POST http://localhost:3000/api/user --data "name=Nic%20Raboy&username=nraboy&password=12345"

응답:

{

"메시지": "성공",

"데이터": {

"cas": "16588775686144"

}

위에서 새 사용자 계정을 만들었습니다.


curl -X GET "http://localhost:3000/api/auth?username=nraboy&amp;password=12345"

RESPONSE:

[
    {
        "name": "Nic Raboy",
        "password": "8cb2237d0679ca88db6464eac60da96345513964",
        "type": "user",
        "uid":"c3e834b0-867e-4a43-aede-b15a4e139adc",
        "username": "nraboy"
    }
]

curl -X GET "http://localhost:3000/api/auth?username=nraboy&password=12345"

응답:

[

{

"name": "닉 라보이",

"비밀번호": "8cb2237d0679ca88db6464eac60da96345513964",

"type": "user",

"uid":"c3e834b0-867e-4a43-aede-b15a4e139adc",

"username": "nraboy"

}

]

위에서 사용자 세션을 만들었습니다. 다른 엔드포인트에도 동일한 전략을 적용할 수 있습니다.

결론

Node.js와 카우치베이스 서버 SDK를 사용하면 게임용 API 백엔드를 쉽게 만들 수 있습니다. 이제 카우치베이스 4.0에서는 애플리케이션의 데이터 쿼리를 위한 옵션으로 N1QL을 자유롭게 사용할 수 있습니다.

이 문서에서 설명한 전체 Node.js 애플리케이션은 다음 링크에서 무료로 다운로드할 수 있습니다. 카우치베이스 랩 깃허브 리포지토리에 저장합니다.

Nic Raboy, 개발자 옹호자, Couchbase

이 문서 공유하기

댓글 하나

마틴 미쿤다 7월 18, 2015에서 3:52 오후

안녕하세요,

'bucket.enableN1ql(\'localshot:8093\');\'을 실행하여 카우치베이스 4에서 여전히 N1QL을 활성화해야 하나요? Thanks

로그인 하여 답글 남기기
1. 매트 인젠트론 7월 18, 2015에서 6:12 오후
  
  아니요, 최신 SDK에서만 작동합니다.
  
  로그인 하여 답글 남기기
  1. hubo 7월 21, 2015에서 2:34 오전
    
    클라이언트의 오류를 문의하고 싶습니다:\"
    
    [com.couchbase.client.deps.io.netty.util.ResourceLeakDetector] LEAK: 가비지 수집되기 전에 ByteBuf.release()가 호출되지 않았습니다. 고급 유출 보고를 활성화하여 유출이 발생한 위치를 파악하세요. 고급 누출 보고를 활성화하려면 JVM 옵션 \'-Dcom.couchbase.client.deps.io.netty.leakDetectionLevel=advanced\'를 지정하거나 ResourceLeakDetector.setLevel()\"을 호출하세요."
    문제란 무엇인가요? 해결 방법
    
    로그인 하여 답글 남기기
JMQ 10월 8, 2015에서 4:12 오후

안녕하세요,

N1QL은 쿼리에만 사용할 수 있나요, 아니면 UPSERT\'s 및 INSERT\'를 수행하는 데 사용할 수 있나요? 고마워요

로그인 하여 답글 남기기
1. 닉 라보이 10월 8, 2015에서 6:16 오후
  
  현재 INSERT, UPDATE, DELETE, UPSERT는 베타 버전입니다. 사용할 수는 있지만 베타 버전에서 벗어날 때까지 프로덕션 환경에서는 사용하지 않는 것이 좋습니다.
  
  http://developer.couchbase.com…
  
  최고,
  
  로그인 하여 답글 남기기

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

Node.js를 사용하여 게임 API 서버 만들기: 재검토

전제 조건

프로젝트 준비하기

데이터베이스 준비하기

Mac

Windows

기본 색인 만들기

프로젝트 구조

기본 사항

API 데이터 모델

사용자 문서

사용자 이름 문서

세션 문서

상태 문서

계정 모델 만들기

세션 모델 만들기

세션 만들기

사용자 인증하기

상태 모델 만들기

저장 상태 만들기

상태 가져오기

API 경로 만들기

API 테스트

결론

받은 편지함에서 카우치베이스 블로그 업데이트 받기

작성자

게시자 Nic Raboy, 개발자 옹호자, Couchbase

댓글 하나

댓글 남기기 응답 취소

카우치베이스 카펠라를 시작할 준비가 되셨나요?

구축 시작

카펠라 무료 사용

연락하기