@cloud-cli/dns 1.1.0 → 2.0.0

package/dist/index.d.ts

@@ -9,17 +9,18 @@ interface DomainAndTarget {
 declare function add(input: DomainAndTarget): boolean;
 declare function remove(input: DomainAndTarget): boolean;
 declare function list(): DomainAndTarget[];
+declare function get(options: {
+    domain: string;
+}): DomainAndTarget | null;
 declare function reload(): Promise<true>;
 declare function addDnsConfig(options: DNSConfig): void;
-export declare function parseDNSLine(line: string): {
-    domain: string;
-    target: string;
-};
+export declare function parseDNSLine(line: string): DomainAndTarget[];
 declare const _default: {
     add: typeof add;
     remove: typeof remove;
     list: typeof list;
     reload: typeof reload;
+    get: typeof get;
     [init]: typeof addDnsConfig;
 };
 export default _default;

package/dist/index.js

@@ -2,8 +2,7 @@ import fs from 'fs';
 import { join } from 'path';
 import { exec } from '@cloud-cli/exec';
 import { init } from '@cloud-cli/cli';
-const lineParse = /^address=\/(.+)\/(.+)$/;
-const filePath = join(process.cwd(), 'configuration', 'apps.conf');
+const filePath = join(process.cwd(), 'configuration', 'hosts.conf');
 const dnsConfig = {
     defaultTarget: '127.0.0.1'
 };
@@ -32,11 +31,15 @@ function list() {
         .trim()
         .split('\n')
         .filter(Boolean)
-        .map(parseDNSLine);
+        .flatMap(parseDNSLine);
     return entries;
 }
+function get(options) {
+    return list().filter(d => d.domain === options.domain)[0] || null;
+}
 async function reload() {
-    const cmd = await exec('systemctl', ['restart', 'dnsmasq']);
+    const getPid = await exec('pidof', ['dnsmasq']);
+    const cmd = await exec('kill', ['-s', 'HUP', getPid.stdout.trim()]);
     return cmd.ok || Promise.reject(new Error('Failed to reload'));
 }
 function addDnsConfig(options) {
@@ -45,12 +48,17 @@ function addDnsConfig(options) {
     }
 }
 function save(list) {
-    const txt = list.map(line => `address=/${line.domain}/${line.target}`);
-    console.log('save', filePath, txt);
-    fs.writeFileSync(filePath, txt.join('\n'));
+    const targets = list.reduce((all, next) => {
+        var _a;
+        all[_a = next.target] || (all[_a] = []);
+        all[next.target].push(next.domain);
+        return all;
+    }, {});
+    const txt = Object.entries(targets).map(([ip, domains]) => `${ip} ${domains.join(' ')}`);
+    fs.writeFileSync(filePath, txt.join('\n').trim());
 }
 export function parseDNSLine(line) {
-    const parts = line.match(lineParse);
-    return { domain: parts[1], target: parts[2] };
+    const [ip, ...domains] = line.split(/\s+/);
+    return domains.map(d => ({ domain: d, target: ip }));
 }
-export default { add, remove, list, reload, [init]: addDnsConfig };
+export default { add, remove, list, reload, get, [init]: addDnsConfig };

package/dist/index.spec.js

@@ -8,13 +8,16 @@ beforeEach(() => {
 });
 describe('dns', () => {
     it('should parse a DNS configuration line', () => {
-        const line = 'address=/foo/1.2.3.4';
+        const line = '1.2.3.4     foo bar';
         const output = parseDNSLine(line);
-        expect(output).toEqual({ target: '1.2.3.4', domain: 'foo' });
+        expect(output).toEqual([
+            { target: '1.2.3.4', domain: 'foo' },
+            { target: '1.2.3.4', domain: 'bar' },
+        ]);
     });
     it('should load entries from file', () => {
         let fileExists = false;
-        const buffer = `address=/test/1.2.3.4\naddress=/foo/5.6.7.8`;
+        const buffer = `1.2.3.4 test\n5.6.7.8 foo`;
         jest.spyOn(fs, 'existsSync').mockImplementation(() => fileExists);
         jest.spyOn(fs, 'readFileSync').mockImplementation(() => buffer);
         expect(dns.list()).toEqual([]);
@@ -25,26 +28,40 @@ describe('dns', () => {
             { domain: 'foo', target: '5.6.7.8' },
         ]);
     });
+    it('should get a DNS entry by domain', () => {
+        let fileExists = false;
+        const buffer = `1.2.3.4 test.com\n5.6.7.8 foo.com`;
+        jest.spyOn(fs, 'existsSync').mockImplementation(() => fileExists);
+        jest.spyOn(fs, 'readFileSync').mockImplementation(() => buffer);
+        expect(dns.get({ domain: 'foo.com' })).toBe(null);
+        fileExists = true;
+        expect(dns.get({ domain: 'foo.com' })).toEqual({ domain: 'foo.com', target: '5.6.7.8' });
+    });
     it('should add and remove local DNS entries', () => {
         let text = '';
         jest.spyOn(fs, 'writeFileSync').mockImplementation((_file, value) => { text = value; });
         jest.spyOn(fs, 'readFileSync').mockImplementation(() => text);
         dns.add({ domain: 'foo', target: '2.3.4.5' });
-        dns.add({ domain: 'bar' });
-        const lines = ['address=/foo/2.3.4.5', 'address=/bar/127.0.0.1'];
-        expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), lines[0]);
+        dns.add({ domain: 'bar', target: '2.3.4.5' });
+        dns.add({ domain: 'baz' });
+        const lines = ['2.3.4.5 foo bar', '127.0.0.1 baz'];
+        expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), '2.3.4.5 foo');
+        expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), '2.3.4.5 foo bar');
         expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), lines.join('\n'));
-        dns.remove({ domain: 'bar' });
+        dns.remove({ domain: 'baz' });
         expect(text).toBe(lines[0]);
     });
     describe('reload', () => {
         it('should reload the DNS service', async () => {
-            jest.spyOn(exec, 'exec').mockResolvedValue({ ok: true });
+            jest.spyOn(exec, 'exec').mockResolvedValueOnce({ ok: true, stdout: '123' });
+            jest.spyOn(exec, 'exec').mockResolvedValueOnce({ ok: true });
             await expect(dns.reload()).resolves.toBe(true);
-            expect(exec.exec).toHaveBeenCalledWith('systemctl', ['restart', 'dnsmasq']);
+            expect(exec.exec).toHaveBeenCalledWith('pidof', ['dnsmasq']);
+            expect(exec.exec).toHaveBeenCalledWith('kill', ['-s', 'HUP', '123']);
         });
         it('should show error on reload', async () => {
-            jest.spyOn(exec, 'exec').mockResolvedValue({ ok: false, stderr: 'error' });
+            jest.spyOn(exec, 'exec').mockResolvedValueOnce({ ok: true, stdout: '123' });
+            jest.spyOn(exec, 'exec').mockResolvedValueOnce({ ok: false, stderr: 'error' });
             await expect(dns.reload()).rejects.toEqual(new Error('Failed to reload'));
         });
     });
@@ -52,7 +69,7 @@ describe('dns', () => {
         it('should configure the default target', () => {
             dns[init]({ defaultTarget: '1.1.2.2' });
             dns.add({ domain: 'bar' });
-            expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), 'address=/bar/1.1.2.2');
+            expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), '1.1.2.2 bar');
         });
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloud-cli/dns",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",

package/src/index.spec.ts

@@ -10,15 +10,18 @@ beforeEach(() => {
 
 describe('dns', () => {
   it('should parse a DNS configuration line', () => {
-    const line = 'address=/foo/1.2.3.4';
+    const line = '1.2.3.4     foo bar';
     const output = parseDNSLine(line);
 
-    expect(output).toEqual({ target: '1.2.3.4', domain: 'foo' });
+    expect(output).toEqual([
+      { target: '1.2.3.4', domain: 'foo' },
+      { target: '1.2.3.4', domain: 'bar' },
+    ]);
   });
 
   it('should load entries from file', () => {
     let fileExists = false;
-    const buffer = `address=/test/1.2.3.4\naddress=/foo/5.6.7.8`;
+    const buffer = `1.2.3.4 test\n5.6.7.8 foo`;
     jest.spyOn(fs, 'existsSync').mockImplementation(() => fileExists);
     jest.spyOn(fs, 'readFileSync').mockImplementation(() => buffer);
 
@@ -32,33 +35,50 @@ describe('dns', () => {
     ])
   });
 
+  it('should get a DNS entry by domain', () => {
+    let fileExists = false;
+    const buffer = `1.2.3.4 test.com\n5.6.7.8 foo.com`;
+    jest.spyOn(fs, 'existsSync').mockImplementation(() => fileExists);
+    jest.spyOn(fs, 'readFileSync').mockImplementation(() => buffer);
+
+    expect(dns.get({ domain: 'foo.com' })).toBe(null);
+
+    fileExists = true;
+    expect(dns.get({ domain: 'foo.com' })).toEqual({ domain: 'foo.com', target: '5.6.7.8' });
+  });
+
   it('should add and remove local DNS entries', () => {
     let text = '';
     jest.spyOn(fs, 'writeFileSync').mockImplementation((_file, value: string) => { text = value; });
     jest.spyOn(fs, 'readFileSync').mockImplementation(() => text);
 
     dns.add({ domain: 'foo', target: '2.3.4.5' });
-    dns.add({ domain: 'bar' });
+    dns.add({ domain: 'bar', target: '2.3.4.5' });
+    dns.add({ domain: 'baz' });
 
-    const lines = ['address=/foo/2.3.4.5', 'address=/bar/127.0.0.1']
+    const lines = ['2.3.4.5 foo bar', '127.0.0.1 baz'];
 
-    expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), lines[0]);
+    expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), '2.3.4.5 foo');
+    expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), '2.3.4.5 foo bar');
     expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), lines.join('\n'));
 
-    dns.remove({ domain: 'bar' });
+    dns.remove({ domain: 'baz' });
     expect(text).toBe(lines[0]);
   });
 
   describe('reload', () => {
     it('should reload the DNS service', async () => {
-      jest.spyOn(exec, 'exec').mockResolvedValue({ ok: true } as any);
+      jest.spyOn(exec, 'exec').mockResolvedValueOnce({ ok: true, stdout: '123' } as any);
+      jest.spyOn(exec, 'exec').mockResolvedValueOnce({ ok: true } as any);
 
       await expect(dns.reload()).resolves.toBe(true);
-      expect(exec.exec).toHaveBeenCalledWith('systemctl', ['restart', 'dnsmasq']);
+      expect(exec.exec).toHaveBeenCalledWith('pidof', ['dnsmasq']);
+      expect(exec.exec).toHaveBeenCalledWith('kill', ['-s', 'HUP', '123']);
     });
 
     it('should show error on reload', async () => {
-      jest.spyOn(exec, 'exec').mockResolvedValue({ ok: false, stderr: 'error' } as any);
+      jest.spyOn(exec, 'exec').mockResolvedValueOnce({ ok: true, stdout: '123' } as any);
+      jest.spyOn(exec, 'exec').mockResolvedValueOnce({ ok: false, stderr: 'error' } as any);
 
       await expect(dns.reload()).rejects.toEqual(new Error('Failed to reload'));
     });
@@ -69,7 +89,7 @@ describe('dns', () => {
       dns[init]({ defaultTarget: '1.1.2.2' });
       dns.add({ domain: 'bar' });
 
-      expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), 'address=/bar/1.1.2.2');
+      expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), '1.1.2.2 bar');
     });
   })
 });

package/src/index.ts

@@ -7,8 +7,7 @@ interface DNSConfig {
   defaultTarget?: string;
 }
 
-const lineParse = /^address=\/(.+)\/(.+)$/;
-const filePath = join(process.cwd(), 'configuration', 'apps.conf');
+const filePath = join(process.cwd(), 'configuration', 'hosts.conf');
 const dnsConfig: DNSConfig = {
   defaultTarget: '127.0.0.1'
 };
@@ -49,13 +48,18 @@ function list(): DomainAndTarget[] {
     .trim()
     .split('\n')
     .filter(Boolean)
-    .map(parseDNSLine)
+    .flatMap(parseDNSLine)
 
   return entries;
 }
 
+function get(options: { domain: string; }): DomainAndTarget | null {
+  return list().filter(d => d.domain === options.domain)[0] || null;
+}
+
 async function reload() {
-  const cmd = await exec('systemctl', ['restart', 'dnsmasq']);
+  const getPid = await exec('pidof', ['dnsmasq']);
+  const cmd = await exec('kill', ['-s', 'HUP', getPid.stdout.trim()]);
   return cmd.ok || Promise.reject(new Error('Failed to reload'));
 }
 
@@ -66,14 +70,20 @@ function addDnsConfig(options: DNSConfig) {
 }
 
 function save(list: DomainAndTarget[]) {
-  const txt = list.map(line => `address=/${line.domain}/${line.target}`);
-  console.log('save', filePath, txt);
-  fs.writeFileSync(filePath, txt.join('\n'));
+  const targets: Record<string, string[]> = list.reduce((all, next) => {
+    all[next.target] ||= [];
+    all[next.target].push(next.domain);
+    return all;
+  }, {});
+
+  const txt = Object.entries(targets).map(([ip, domains]) => `${ip} ${domains.join(' ')}`);
+
+  fs.writeFileSync(filePath, txt.join('\n').trim());
 }
 
-export function parseDNSLine(line: string) {
-  const parts = line.match(lineParse);
-  return { domain: parts[1], target: parts[2] }
+export function parseDNSLine(line: string): DomainAndTarget[] {
+  const [ip, ...domains] = line.split(/\s+/);
+  return domains.map(d => ({ domain: d, target: ip }));
 }
 
-export default { add, remove, list, reload, [init]: addDnsConfig }
+export default { add, remove, list, reload, get, [init]: addDnsConfig }