push.rocks/smartdns
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

BREAKING CHANGE(package): update to new packagename and improve record retrieval

Browse Source
This commit is contained in:
Philipp Kunz
2018-05-13 15:51:04 +02:00
parent 3e45a24750
commit 4ada87a945
13 changed files with 365 additions and 620 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
ts/dnsly.plugins.ts
View File

@ -1,10 +1,5 @@
import 'typings-global'
import * as beautylog from 'beautylog'
import * as dns from 'dns'
import * as smartdelay from 'smartdelay'
import * as beautylog from 'beautylog';
import * as dns from 'dns';
import * as smartdelay from 'smartdelay';
export {
beautylog,
dns,
smartdelay
}
export { beautylog, dns, smartdelay };

141
ts/index.ts
View File

@ -1,8 +1,9 @@
import * as q from 'smartq'
import * as plugins from './dnsly.plugins'
import * as smartq from 'smartq';
import * as plugins from './dnsly.plugins';
export type TDnsProvider = 'google'
export type TDnsRecordType = 'A'
export type TDnsProvider = 'google';
export type TDnsRecordType =
| 'A'
| 'AAAA'
| 'CNAME'
| 'PTR'
@ -11,140 +12,142 @@ export type TDnsRecordType = 'A'
| 'NS'
| 'SOA'
| 'SRV'
| 'TXT'
| 'TXT';
export interface IDnsRecord {
chunked?: string[]
name: string
type: TDnsRecordType
value: string
chunked?: string[];
name: string;
type: TDnsRecordType;
value: string;
}
/**
* class dnsly offers methods for working with dns from a dns provider like Google DNS
*/
export class Dnsly {
dnsServerIp: string
dnsServerPort: number
export class Smartdns {
dnsServerIp: string;
dnsServerPort: number;
/**
* constructor for class dnsly
*/
constructor(dnsProviderArg: TDnsProvider = 'google') {
this._setDnsProvider(dnsProviderArg)
this._setDnsProvider(dnsProviderArg);
}
/**
* gets a record
*/
async getRecord (recordNameArg: string, recordTypeArg: TDnsRecordType): Promise<IDnsRecord[]> {
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
async checkUntilAvailable(
recordNameArg: string,
recordTypeArg: TDnsRecordType,
expectedValue: string
) {
let cycleArg = 0;
let doCheck = async () => {
if (cycleArg < 30) {
cycleArg++
cycleArg++;
try {
let myRecordArray = await this.getRecord(recordNameArg, recordTypeArg)
let myRecord = myRecordArray[0].value
let myRecordArray = await this.getRecord(recordNameArg, recordTypeArg);
let myRecord = myRecordArray[0].value;
if (myRecord === expectedValue) {
return true
return true;
} else {
await plugins.smartdelay.delayFor(500)
return await doCheck()
await plugins.smartdelay.delayFor(500);
return await doCheck();
}
} catch (err) {
await plugins.smartdelay.delayFor(500)
return await doCheck()
await plugins.smartdelay.delayFor(500);
return await doCheck();
}
} else {
console.log('failed permanently...')
return false
console.log('failed permanently...');
return false;
}
}
return await doCheck()
};
return await doCheck();
}
/**
* get A Dns Record
*/
async getRecordA (recordNameArg: string): Promise<IDnsRecord[]> {
return await this.getOrdinaryRecord(recordNameArg, 'A')
async getRecordA(recordNameArg: string): Promise<IDnsRecord[]> {
return await this.getRecord(recordNameArg, 'A');
}
/**
* get AAAA Record
*/
async getRecordAAAA (recordNameArg: string) {
return await this.getOrdinaryRecord(recordNameArg, 'AAAA')
async getRecordAAAA(recordNameArg: string) {
return await this.getRecord(recordNameArg, 'AAAA');
}
/**
* gets a txt record
*/
getRecordTxt (recordNameArg: string): Promise<IDnsRecord[]> {
let done = q.defer<IDnsRecord[]>()
getRecordTxt(recordNameArg: string): Promise<IDnsRecord[]> {
let done = smartq.defer<IDnsRecord[]>();
plugins.dns.resolveTxt(recordNameArg, (err, recordsArg) => {
if (err) {
done.reject(err)
return
done.reject(err);
return;
}
let responseArray: IDnsRecord[] = []
let responseArray: IDnsRecord[] = [];
for (let record of recordsArg) {
let recordAny: any = record // fix wrong typings
let recordAny: any = record; // fix wrong typings
responseArray.push({
chunked: recordAny,
name: recordNameArg,
value: recordAny.join(' '),
type: 'TXT'
})
});
}
done.resolve(responseArray)
})
return done.promise
done.resolve(responseArray);
});
return done.promise;
}
/**
* get oridinary record
*/
private getOrdinaryRecord (recordNameArg: string, recordTypeArg: TDnsRecordType): Promise<IDnsRecord[]> {
let done = q.defer<IDnsRecord[]>()
getRecord(recordNameArg: string, recordTypeArg: TDnsRecordType): Promise<IDnsRecord[]> {
let done = smartq.defer<IDnsRecord[]>();
plugins.dns.resolve(recordNameArg, recordTypeArg, (err, recordsArg) => {
if (err) {
done.reject(err)
return
done.reject(err);
return;
}
let responseArray: IDnsRecord[] = []
let responseArray: IDnsRecord[] = [];
for (let recordKey in recordsArg) {
responseArray.push({
name: recordNameArg,
value: recordsArg[recordKey],
type: recordTypeArg
})
});
}
done.resolve(responseArray)
})
return done.promise
done.resolve(responseArray);
});
return done.promise;
}
getNameServer(domainNameArg: string) {
const done = smartq.defer();
plugins.dns.resolveNs(domainNameArg, (err, result) => {
if (!err) {
done.resolve(result);
} else {
console.log(err);
done.reject(err);
}
});
}
/**
* set the DNS provider
*/
private _setDnsProvider (dnsProvider: TDnsProvider) {
private _setDnsProvider(dnsProvider: TDnsProvider) {
if (dnsProvider === 'google') {
this.dnsServerIp = '8.8.8.8'
this.dnsServerPort = 53
plugins.dns.setServers(['8.8.8.8', '8.8.4.4'])
this.dnsServerIp = '8.8.8.8';
this.dnsServerPort = 53;
plugins.dns.setServers(['8.8.8.8', '8.8.4.4']);
} else {
throw new Error('unknown dns provider')
throw new Error('unknown dns provider');
}
}
}