From 46aa5453249bfd2d28d3e4e997d898e6fe072595 Mon Sep 17 00:00:00 2001 From: Phil Kunz Date: Fri, 27 Jan 2017 00:11:13 +0100 Subject: [PATCH] update to better API --- dist/dnsly.plugins.d.ts | 3 +- dist/dnsly.plugins.js | 4 +- dist/index.d.ts | 29 +++++++++-- dist/index.js | 110 ++++++++++++++++++++++++++++++++++++++-- package.json | 7 ++- test/test.js | 42 +++++++++++---- test/test.ts | 43 ++++++++++++---- ts/dnsly.plugins.ts | 4 +- ts/index.ts | 109 ++++++++++++++++++++++++++++++++++++--- 9 files changed, 306 insertions(+), 45 deletions(-) diff --git a/dist/dnsly.plugins.d.ts b/dist/dnsly.plugins.d.ts index f24c7aa..611108c 100644 --- a/dist/dnsly.plugins.d.ts +++ b/dist/dnsly.plugins.d.ts @@ -1,4 +1,5 @@ import 'typings-global'; import * as beautylog from 'beautylog'; import * as dns from 'dns'; -export { beautylog, dns }; +import * as smartdelay from 'smartdelay'; +export { beautylog, dns, smartdelay }; diff --git a/dist/dnsly.plugins.js b/dist/dnsly.plugins.js index 03b72f2..38d78bc 100644 --- a/dist/dnsly.plugins.js +++ b/dist/dnsly.plugins.js @@ -4,4 +4,6 @@ const beautylog = require("beautylog"); exports.beautylog = beautylog; const dns = require("dns"); exports.dns = dns; -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG5zbHkucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2Ruc2x5LnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLDBCQUF1QjtBQUN2Qix1Q0FBc0M7QUFJbEMsOEJBQVM7QUFIYiwyQkFBMEI7QUFJdEIsa0JBQUcifQ== \ No newline at end of file +const smartdelay = require("smartdelay"); +exports.smartdelay = smartdelay; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG5zbHkucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2Ruc2x5LnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLDBCQUF1QjtBQUN2Qix1Q0FBc0M7QUFLbEMsOEJBQVM7QUFKYiwyQkFBMEI7QUFLdEIsa0JBQUc7QUFKUCx5Q0FBd0M7QUFLcEMsZ0NBQVUifQ== \ No newline at end of file diff --git a/dist/index.d.ts b/dist/index.d.ts index f35a3a4..47c4781 100644 --- a/dist/index.d.ts +++ b/dist/index.d.ts @@ -1,7 +1,11 @@ -/// -import * as q from 'q'; export declare type TDnsProvider = 'google'; export declare type TDnsRecordType = 'A' | 'AAAA' | 'CNAME' | 'PTR' | 'MX' | 'NAPTR' | 'NS' | 'SOA' | 'SRV' | 'TXT'; +export interface IDnsRecord { + chunked?: string[]; + name: string; + type: TDnsRecordType; + value: string; +} /** * class dnsly offers methods for working with dns from a dns provider like Google DNS */ @@ -11,11 +15,28 @@ export declare class Dnsly { /** * constructor for class dnsly */ - constructor(dnsProviderArg: TDnsProvider); + constructor(dnsProviderArg?: TDnsProvider); /** * gets a record */ - getRecord(recordNameArg: string, recordTypeArg: TDnsRecordType): q.Promise<{}>; + getRecord(recordNameArg: string, recordTypeArg: TDnsRecordType): Promise; + checkUntilAvailable(recordNameArg: string, recordTypeArg: TDnsRecordType, expectedValue: string): Promise; + /** + * get A Dns Record + */ + getRecordA(recordNameArg: string): Promise; + /** + * get AAAA Record + */ + getRecordAAAA(recordNameArg: string): Promise; + /** + * gets a txt record + */ + getRecordTxt(recordNameArg: string): Promise; + /** + * get oridinary record + */ + private getOrdinaryRecord(recordNameArg, recordTypeArg); /** * set the DNS provider */ diff --git a/dist/index.js b/dist/index.js index 33435d4..9c37424 100644 --- a/dist/index.js +++ b/dist/index.js @@ -1,5 +1,13 @@ "use strict"; -const q = require("q"); +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +const q = require("smartq"); const plugins = require("./dnsly.plugins"); /** * class dnsly offers methods for working with dns from a dns provider like Google DNS @@ -8,19 +16,111 @@ class Dnsly { /** * constructor for class dnsly */ - constructor(dnsProviderArg) { + constructor(dnsProviderArg = 'google') { this._setDnsProvider(dnsProviderArg); } /** * gets a record */ getRecord(recordNameArg, recordTypeArg) { + return __awaiter(this, void 0, void 0, function* () { + switch (recordTypeArg) { + case 'TXT': + return yield this.getRecordTxt(recordNameArg); + case 'A': + return yield this.getRecordA(recordNameArg); + case 'AAAA': + return yield this.getRecordAAAA(recordNameArg); + } + }); + } + checkUntilAvailable(recordNameArg, recordTypeArg, expectedValue) { + return __awaiter(this, void 0, void 0, function* () { + let cycleArg = 0; + let doCheck = () => __awaiter(this, void 0, void 0, function* () { + if (cycleArg < 30) { + cycleArg++; + try { + let myRecordArray = yield this.getRecord(recordNameArg, recordTypeArg); + let myRecord = myRecordArray[0].value; + if (myRecord === expectedValue) { + return true; + } + else { + yield plugins.smartdelay.delayFor(500); + return yield doCheck(); + } + } + catch (err) { + yield plugins.smartdelay.delayFor(500); + return yield doCheck(); + } + } + else { + console.log('failed permanently...'); + return false; + } + }); + return yield doCheck(); + }); + } + /** + * get A Dns Record + */ + getRecordA(recordNameArg) { + return __awaiter(this, void 0, void 0, function* () { + return yield this.getOrdinaryRecord(recordNameArg, 'A'); + }); + } + /** + * get AAAA Record + */ + getRecordAAAA(recordNameArg) { + return __awaiter(this, void 0, void 0, function* () { + return yield this.getOrdinaryRecord(recordNameArg, 'AAAA'); + }); + } + /** + * gets a txt record + */ + getRecordTxt(recordNameArg) { let done = q.defer(); - plugins.dns.resolve(recordNameArg, recordTypeArg, (err, addresses) => { + plugins.dns.resolveTxt(recordNameArg, (err, recordsArg) => { if (err) { done.reject(err); } - done.resolve(addresses); + let responseArray = []; + for (let record of recordsArg) { + let recordAny = record; // fix wrong typings + responseArray.push({ + chunked: recordAny, + name: recordNameArg, + value: recordAny.join(' '), + type: 'TXT' + }); + } + done.resolve(responseArray); + }); + return done.promise; + } + /** + * get oridinary record + */ + getOrdinaryRecord(recordNameArg, recordTypeArg) { + let done = q.defer(); + plugins.dns.resolve(recordNameArg, recordTypeArg, (err, recordsArg) => { + if (err) { + done.reject(err); + } + let responseArray = []; + for (let record of recordsArg) { + responseArray.push({ + name: recordNameArg, + value: record, + type: recordTypeArg + }); + } + done.resolve(responseArray); }); return done.promise; } @@ -39,4 +139,4 @@ class Dnsly { } } exports.Dnsly = Dnsly; -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsdUJBQXNCO0FBQ3RCLDJDQUEwQztBQWMxQzs7R0FFRztBQUNIO0lBR0k7O09BRUc7SUFDSCxZQUFZLGNBQTRCO1FBQ3BDLElBQUksQ0FBQyxlQUFlLENBQUMsY0FBYyxDQUFDLENBQUE7SUFDeEMsQ0FBQztJQUVEOztPQUVHO0lBQ0gsU0FBUyxDQUFDLGFBQXFCLEVBQUUsYUFBNkI7UUFDMUQsSUFBSSxJQUFJLEdBQUcsQ0FBQyxDQUFDLEtBQUssRUFBRSxDQUFBO1FBQ3BCLE9BQU8sQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLGFBQWEsRUFBQyxhQUFhLEVBQUUsQ0FBQyxHQUFHLEVBQUUsU0FBUztZQUM1RCxFQUFFLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDO2dCQUNOLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUE7WUFDcEIsQ0FBQztZQUNELElBQUksQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLENBQUE7UUFDM0IsQ0FBQyxDQUFDLENBQUE7UUFDRixNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQTtJQUN2QixDQUFDO0lBRUQ7O09BRUc7SUFDSyxlQUFlLENBQUMsV0FBeUI7UUFDN0MsRUFBRSxDQUFDLENBQUMsV0FBVyxLQUFLLFFBQVEsQ0FBQyxDQUFDLENBQUM7WUFDM0IsSUFBSSxDQUFDLFdBQVcsR0FBRyxTQUFTLENBQUE7WUFDNUIsSUFBSSxDQUFDLGFBQWEsR0FBRyxFQUFFLENBQUE7WUFDdkIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsQ0FBQyxTQUFTLEVBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQTtRQUNqRCxDQUFDO1FBQUMsSUFBSSxDQUFDLENBQUM7WUFDSixNQUFNLElBQUksS0FBSyxDQUFDLHNCQUFzQixDQUFDLENBQUE7UUFDM0MsQ0FBQztJQUNMLENBQUM7Q0FDSjtBQXBDRCxzQkFvQ0MifQ== \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/package.json b/package.json index afab846..4cdfa46 100644 --- a/package.json +++ b/package.json @@ -23,14 +23,13 @@ }, "homepage": "https://gitlab.com/pushrocks/dnsly#README", "dependencies": { - "@types/q": "0.0.32", "beautylog": "^6.0.0", - "q": "^1.4.1", + "smartdelay": "^1.0.1", + "smartq": "^1.0.4", "typings-global": "^1.0.14" }, "devDependencies": { - "@types/should": "^8.1.30", - "should": "^11.1.1", + "smartchai": "^1.0.1", "typings-test": "^1.0.3" } } diff --git a/test/test.js b/test/test.js index 7eb8802..9e95b5f 100644 --- a/test/test.js +++ b/test/test.js @@ -1,21 +1,34 @@ "use strict"; require("typings-test"); -const should = require("should"); +const smartchai_1 = require("smartchai"); const dnsly = require("../dist/index"); let testDnsly; describe('dnsly', function () { it('should create an instance of Dnsly', function () { testDnsly = new dnsly.Dnsly('google'); - should(testDnsly).be.instanceOf(dnsly.Dnsly); + smartchai_1.expect(testDnsly).to.be.instanceOf(dnsly.Dnsly); }); - it('should, get a dns record for a domain', function (done) { - testDnsly.getRecord('google.com', 'A').then(res => { - console.log(res); - done(); - }).catch(err => { - console.log(err); - done(err); - }); + it('should get an A DNS Record', function () { + return smartchai_1.expect(testDnsly.getRecordA('dnsly_a.bleu.de')).to.eventually.deep.equal([{ + name: 'dnsly_a.bleu.de', + value: '127.0.0.1', + type: 'A' + }]); + }); + it('should get an AAAA Record', function () { + return smartchai_1.expect(testDnsly.getRecordAAAA('dnsly_aaaa.bleu.de')).to.eventually.deep.equal([{ + name: 'dnsly_aaaa.bleu.de', + value: '::1', + type: 'AAAA' + }]); + }); + it('should get a txt record', function () { + return smartchai_1.expect(testDnsly.getRecordTxt('dnsly_txt.bleu.de')).to.eventually.deep.equal([{ + chunked: ['sometext_txt'], + name: 'dnsly_txt.bleu.de', + value: 'sometext_txt', + type: 'TXT' + }]); }); it('should, get a mx record for a domain', function (done) { testDnsly.getRecord('google.com', 'MX').then(res => { @@ -26,5 +39,12 @@ describe('dnsly', function () { done(err); }); }); + it('should check until DNS is available', function () { + return smartchai_1.expect(testDnsly.checkUntilAvailable('dnsly_txt.bleu.de', 'TXT', 'sometext_txt')).to.eventually.be.true; + }); + it('should check until DNS is available an return false if it fails', function () { + this.timeout(30000); + return smartchai_1.expect(testDnsly.checkUntilAvailable('dnsly_txt.bleu.de', 'TXT', 'sometext_txt2')).to.eventually.be.false; + }); }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLHdCQUFxQjtBQUNyQixpQ0FBZ0M7QUFFaEMsdUNBQXNDO0FBRXRDLElBQUksU0FBc0IsQ0FBQTtBQUUxQixRQUFRLENBQUMsT0FBTyxFQUFFO0lBQ2QsRUFBRSxDQUFDLG9DQUFvQyxFQUFFO1FBQ3JDLFNBQVMsR0FBRyxJQUFJLEtBQUssQ0FBQyxLQUFLLENBQUMsUUFBUSxDQUFDLENBQUE7UUFDckMsTUFBTSxDQUFDLFNBQVMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxVQUFVLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFBO0lBQ2hELENBQUMsQ0FBQyxDQUFBO0lBRUYsRUFBRSxDQUFDLHVDQUF1QyxFQUFFLFVBQVUsSUFBSTtRQUN0RCxTQUFTLENBQUMsU0FBUyxDQUFDLFlBQVksRUFBRSxHQUFHLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRztZQUMzQyxPQUFPLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFBO1lBQ2hCLElBQUksRUFBRSxDQUFBO1FBQ1YsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLEdBQUc7WUFDUixPQUFPLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFBO1lBQ2hCLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQTtRQUNiLENBQUMsQ0FBQyxDQUFBO0lBRU4sQ0FBQyxDQUFDLENBQUE7SUFFRixFQUFFLENBQUMsc0NBQXNDLEVBQUUsVUFBVSxJQUFJO1FBQ3JELFNBQVMsQ0FBQyxTQUFTLENBQUMsWUFBWSxFQUFFLElBQUksQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHO1lBQzVDLE9BQU8sQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUE7WUFDaEIsSUFBSSxFQUFFLENBQUE7UUFDVixDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsR0FBRztZQUNSLE9BQU8sQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUE7WUFDaEIsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFBO1FBQ2IsQ0FBQyxDQUFDLENBQUE7SUFFTixDQUFDLENBQUMsQ0FBQTtBQUNOLENBQUMsQ0FBQyxDQUFBIn0= \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/test/test.ts b/test/test.ts index 7d7f92d..6931b5b 100644 --- a/test/test.ts +++ b/test/test.ts @@ -1,5 +1,5 @@ import 'typings-test' -import * as should from 'should' +import { expect } from 'smartchai' import * as dnsly from '../dist/index' @@ -8,18 +8,32 @@ let testDnsly: dnsly.Dnsly describe('dnsly', function () { it('should create an instance of Dnsly', function () { testDnsly = new dnsly.Dnsly('google') - should(testDnsly).be.instanceOf(dnsly.Dnsly) + expect(testDnsly).to.be.instanceOf(dnsly.Dnsly) }) - it('should, get a dns record for a domain', function (done) { - testDnsly.getRecord('google.com', 'A').then(res => { - console.log(res) - done() - }).catch(err => { - console.log(err) - done(err) - }) + it('should get an A DNS Record', function () { + return expect(testDnsly.getRecordA('dnsly_a.bleu.de')).to.eventually.deep.equal([{ + name: 'dnsly_a.bleu.de', + value: '127.0.0.1', + type: 'A' + }]) + }) + it('should get an AAAA Record', function () { + return expect(testDnsly.getRecordAAAA('dnsly_aaaa.bleu.de')).to.eventually.deep.equal([{ + name: 'dnsly_aaaa.bleu.de', + value: '::1', + type: 'AAAA' + }]) + }) + + it('should get a txt record', function() { + return expect(testDnsly.getRecordTxt('dnsly_txt.bleu.de')).to.eventually.deep.equal([{ + chunked: ['sometext_txt'], + name: 'dnsly_txt.bleu.de', + value: 'sometext_txt', + type: 'TXT' + }]) }) it('should, get a mx record for a domain', function (done) { @@ -32,4 +46,13 @@ describe('dnsly', function () { }) }) + + it('should check until DNS is available', function() { + return expect(testDnsly.checkUntilAvailable('dnsly_txt.bleu.de','TXT','sometext_txt')).to.eventually.be.true + }) + + it('should check until DNS is available an return false if it fails', function() { + this.timeout(30000) + return expect(testDnsly.checkUntilAvailable('dnsly_txt.bleu.de','TXT','sometext_txt2')).to.eventually.be.false + }) }) diff --git a/ts/dnsly.plugins.ts b/ts/dnsly.plugins.ts index e0c374b..7e7ce1f 100644 --- a/ts/dnsly.plugins.ts +++ b/ts/dnsly.plugins.ts @@ -1,8 +1,10 @@ import 'typings-global' import * as beautylog from 'beautylog' import * as dns from 'dns' +import * as smartdelay from 'smartdelay' export { beautylog, - dns + dns, + smartdelay } diff --git a/ts/index.ts b/ts/index.ts index 50c9a3f..100d1b4 100644 --- a/ts/index.ts +++ b/ts/index.ts @@ -1,4 +1,4 @@ -import * as q from 'q' +import * as q from 'smartq' import * as plugins from './dnsly.plugins' export type TDnsProvider = 'google' @@ -13,6 +13,13 @@ export type TDnsRecordType = 'A' | 'SRV' | 'TXT' +export interface IDnsRecord { + chunked?: string[] + name: string + type: TDnsRecordType + value: string +} + /** * class dnsly offers methods for working with dns from a dns provider like Google DNS */ @@ -22,20 +29,106 @@ export class Dnsly { /** * constructor for class dnsly */ - constructor(dnsProviderArg: TDnsProvider) { + constructor(dnsProviderArg: TDnsProvider = 'google') { this._setDnsProvider(dnsProviderArg) } /** * gets a record */ - getRecord(recordNameArg: string, recordTypeArg: TDnsRecordType) { - let done = q.defer() - plugins.dns.resolve(recordNameArg,recordTypeArg, (err, addresses) => { + async getRecord(recordNameArg: string, recordTypeArg: TDnsRecordType): Promise { + switch (recordTypeArg) { + case 'TXT': + return await this.getRecordTxt(recordNameArg) + case 'A': + return await this.getRecordA(recordNameArg) + case 'AAAA': + return await this.getRecordAAAA(recordNameArg) + } + } + + async checkUntilAvailable(recordNameArg: string, recordTypeArg: TDnsRecordType, expectedValue: string) { + let cycleArg = 0 + let doCheck = async () => { + if (cycleArg < 30) { + cycleArg++ + try { + let myRecordArray = await this.getRecord(recordNameArg, recordTypeArg) + let myRecord = myRecordArray[0].value + if (myRecord === expectedValue) { + return true + } else { + await plugins.smartdelay.delayFor(500) + return await doCheck() + } + } catch (err) { + await plugins.smartdelay.delayFor(500) + return await doCheck() + } + } else { + console.log('failed permanently...') + return false + } + } + return await doCheck() + } + + /** + * get A Dns Record + */ + async getRecordA(recordNameArg: string): Promise { + return await this.getOrdinaryRecord(recordNameArg, 'A') + } + + /** + * get AAAA Record + */ + async getRecordAAAA(recordNameArg: string) { + return await this.getOrdinaryRecord(recordNameArg, 'AAAA') + } + + /** + * gets a txt record + */ + getRecordTxt(recordNameArg: string): Promise { + let done = q.defer() + plugins.dns.resolveTxt(recordNameArg, (err, recordsArg) => { if (err) { done.reject(err) } - done.resolve(addresses) + let responseArray: IDnsRecord[] = [] + for (let record of recordsArg) { + let recordAny: any = record // fix wrong typings + responseArray.push({ + chunked: recordAny, + name: recordNameArg, + value: recordAny.join(' '), + type: 'TXT' + }) + } + done.resolve(responseArray) + }) + return done.promise + } + + /** + * get oridinary record + */ + private getOrdinaryRecord(recordNameArg: string, recordTypeArg: TDnsRecordType): Promise { + let done = q.defer() + plugins.dns.resolve(recordNameArg, recordTypeArg, (err, recordsArg) => { + if (err) { + done.reject(err) + } + let responseArray: IDnsRecord[] = [] + for (let record of recordsArg) { + responseArray.push({ + name: recordNameArg, + value: record, + type: recordTypeArg + }) + } + done.resolve(responseArray) }) return done.promise } @@ -47,9 +140,9 @@ export class Dnsly { if (dnsProvider === 'google') { this.dnsServerIp = '8.8.8.8' this.dnsServerPort = 53 - plugins.dns.setServers(['8.8.8.8','8.8.4.4']) + plugins.dns.setServers(['8.8.8.8', '8.8.4.4']) } else { throw new Error('unknown dns provider') } } -} \ No newline at end of file +}