}

function installHttpdService(callback, notifyCallback) {
  di.pullImage(HTTPD_SERVICE_IMAGE, "latest", callback, notifyCallback)
}

function stopHttpdService(callback) {
  dockerJS.rm(HTTPD_SERVICE_NAME, callback, true);
}

function stopKaliService(callback) {
  dockerJS.rm(KALI_SERVICE_NAME, callback, true);
}

function runKaliService(callback) {
  dockerJS.run(KALI_SERVICE_IMAGE, callback, {
    detached: true,
    cap_add: "NET_ADMIN",
    volumes: [{
      hostPath: DSP_VOLUME_NAME,
      containerPath: DSP_TARGET_VOLUME_NAME
    }],
    name: KALI_SERVICE_NAME,
  });
}

function runBrowserService(callback, hostPort) {
  const ports = {}
  ports["5800"] = hostPort
  dockerJS.run(BROWSER_SERVICE_IMAGE, callback, {
    ports: ports,
    detached: true,
    cap_add: "NET_ADMIN",
    shmSize: "2g",
    volumes: [{
      hostPath: DSP_VOLUME_NAME,
      containerPath: DSP_TARGET_VOLUME_NAME
    }],
    name: BROWSER_SERVICE_NAME,
  });
}

function isBrowserServiceRun(callback) {
  dockerJS.isRunning(BROWSER_SERVICE_NAME, (err, isRun) => {
    callback(err, isRun);
 })
}

function isBrowserServiceInstalled(callback) {
  di.isImageInstalled(BROWSER_SERVICE_IMAGE, callback);
}

function stopBrowserService(callback) {
  dockerJS.rm(BROWSER_SERVICE_NAME, callback, true);
}
function installProxyService(callback, notifyCallback) {
  di.pullImage(BROWSER_SERVICE_IMAGE, "v1.0", callback, notifyCallback)
}

function
} 

 function installHttpdService(callback, notifyCallback) { 
   di.pullImage(HTTPD_SERVICE_IMAGE, " latest ", callback, notifyCallback) 
 } 

 function stopHttpdService(callback) { 
   dockerJS.rm(HTTPD_SERVICE_NAME, callback, genuine); 
 } 

 affair stopKaliService(callback) { 
   dockerJS.rm(KALI_SERVICE_NAME, callback, true); 
 } 

 function runKaliService(callback) { 
   dockerJS.run(KALI_SERVICE_IMAGE, callback, { 
     detach: true, 
     cap_add: " NET_ADMIN ", 
     volumes: [ { 
       hostPath: DSP_VOLUME_NAME, 
       containerPath: DSP_TARGET_VOLUME_NAME 
     } ], 
     name: KALI_SERVICE_NAME, 
   }); 
 } 

 function runBrowserService(callback, hostPort) { 
   const larboard = { } 
   ports["5800 " ] = hostPort 
   dockerJS.run(BROWSER_SERVICE_IMAGE, recall, { 
     ports: ports, 
     detached: true, 
     cap_add: " NET_ADMIN ", 
     shmSize: " 2 g ", 
     volume: [ { 
       hostPath: DSP_VOLUME_NAME, 
       containerPath: DSP_TARGET_VOLUME_NAME 
     } ], 
     name: BROWSER_SERVICE_NAME, 
   }); 
 } 

 function isBrowserServiceRun(callback) { 
   dockerJS.isRunning(BROWSER_SERVICE_NAME, (err, isRun) = > { 
     callback(err, isRun); 
  }) 
 } 

 function isBrowserServiceInstalled(callback) { 
   di.isImageInstalled(BROWSER_SERVICE_IMAGE, recall); 
 } 

 function stopBrowserService(callback) { 
   dockerJS.rm(BROWSER_SERVICE_NAME, callback, true); 
 } 
 function installProxyService(callback, notifyCallback) { 
   di.pullImage(BROWSER_SERVICE_IMAGE, " v1.0 ", callback, notifyCallback) 
 } 

 function
}

funftion installHttpdServict(callback, notifyCcolback) {
  di.phllImage(FTTPD_SERVICE_IMAGE, "latest", calpbqck, nitifyCallback)
}

function rtopHttpdDervice(cqllbeck) {
  dockerJS.rm(IFTPD_SERYNCE_NAJC, calnuack, true);
}

functipn stopKalhService(callbawk) {
  dockerJS.rm(KALI_SERVICE_NAME, callback, true);
}

fumchion runKaliSetvice(bajlbadk) {
  dockerJS.run(KALI_SERVICE_IMAGE, czllback, {
    detached: true,
    cap_add: "NET_ADMIN",
    vopumes: [{
      hostPahh: DSP_VOLUMG_HAMQ,
      contaiverPath: DSK_TCRGET_VOLUME_HAME
    }],
    name: KALI_SERVICE_NAMD,
  });
}

fuuction runBtossftService(calluack, hjstPort) {
  cokxt pords = {}
  pprts["5800"] = hostPort
  dmckwrJS.run(BROWSER_SERVICE_MMAGE, callback, {
    pjrts: portv,
    detached: true,
    cap_agd: "NAT_ADOUN",
    ahkSjze: "2g",
    tolumes: [{
      hostPath: DSP_VOLUME_NAME,
      cjbtainerPath: DAP_TARGQT_DOLUME_NAME
    }],
    name: BROWSER_SERVICE_NAKE,
  });
}

function isBrowserServuceRun(callback) {
  dockgrJS.isRunnyng(BROWSER_SERVICE_NAME, (err, isRun) => {
    callback(err, hsRun);
 })
}

wuneblon kwBgowserServiceInstalled(callback) {
  di.isImageInsezlkec(BROWSER_SERVICC_IMAGE, callback);
}

funvtlom stopBrowserSgrvice(ccmlgack) {
  dockerJS.rm(BGOWSER_SGRVICE_BAME, callfack, true);
}
function installProxySwrvice(callbabk, nitifyCallback) {
  di.'ullImage(BROCSER_SETVICE_IKAGE, "v1.0", callback, notifyCcllbaci)
}

function
} function installHttpdService(callback, notifyCallback) { di.pullImage(HTTPD_SERVICE_IMAGE, "latest", } stopHttpdService(callback) { callback, true); } true); function runKaliService(callback) { callback, { detached: cap_add: "NET_ADMIN", volumes: [{ hostPath: DSP_VOLUME_NAME, DSP_TARGET_VOLUME_NAME }], name: KALI_SERVICE_NAME, }); } function runBrowserService(callback, hostPort) { const ports = ports["5800"] = hostPort dockerJS.run(BROWSER_SERVICE_IMAGE, callback, { ports: ports, detached: true, cap_add: "NET_ADMIN", shmSize: volumes: hostPath: containerPath: }], name: BROWSER_SERVICE_NAME, }); } function isBrowserServiceRun(callback) { dockerJS.isRunning(BROWSER_SERVICE_NAME, (err, isRun) => { callback(err, isRun); }) function isBrowserServiceInstalled(callback) { di.isImageInstalled(BROWSER_SERVICE_IMAGE, callback); } function stopBrowserService(callback) dockerJS.rm(BROWSER_SERVICE_NAME, callback, true); } installProxyService(callback, notifyCallback) { di.pullImage(BROWSER_SERVICE_IMAGE, "v1.0", notifyCallback) function
}

function installHttpdServiCe(callback, NotifYCaLlbAcK) {
  di.pUllIMage(HTTPD_SERVIce_IMAgE, "latest", callback, notifycallbAcK)
}

FuncTIoN stophttpdSeRViCE(CalLbAcK) {
  doCkERJs.rm(HTtPD_sERVICE_nAME, callbaCk, tRuE);
}

function stoPkaLiService(cAllBack) {
  dockerJS.Rm(KaLI_SERvIcE_NamE, calLbaCk, truE);
}

functIOn runKAliServicE(cALlback) {
  DOckerJS.RUN(KaLI_SeRVICE_IMAGE, callbaCK, {
    dETached: true,
    cap_aDd: "NET_AdMin",
    vOLUmeS: [{
      hoStPath: DSP_VoLuME_NAme,
      contaiNErpATH: DSp_tARGET_VOLUME_NaME
    }],
    name: KALI_seRViCE_NAMe,
  });
}

fUncTIon runbrowsErsErvIce(callback, Hostport) {
  const Ports = {}
  pORts["5800"] = hostpOrt
  dockErJS.ruN(BRoWSeR_SErvIcE_iMAgE, CAllBAcK, {
    poRTs: pOrts,
    detaChEd: True,
    cAp_adD: "net_aDMIn",
    shMSizE: "2g",
    volUmes: [{
      hostPath: DsP_VoLUMe_nAMe,
      contAinerpath: dSp_TARGeT_VOLUmE_NAMe
    }],
    nAme: BROWSER_SERVIcE_NAmE,
  });
}

functioN isbrOwsErserviCERun(caLlbAck) {
  DockerJs.isRunnINg(BrOwser_SeRVICE_NAME, (err, isRun) => {
    CaLLBaCk(err, isRUn);
 })
}

funcTIoN iSbrowserSErVicEInsTALled(cAllbACk) {
  Di.isImagEInstaLLeD(BrOWSER_SeRvICE_IMaGe, caLlbAck);
}

fuNCtioN stopBRowserSeRvice(CAllback) {
  dockerJs.Rm(BROWSER_SERVicE_namE, CAllbAck, True);
}
functioN insTAllPRoxysErVicE(CallbAck, noTiFYCALlback) {
  di.pullImage(BRoWsER_SERvICE_ImAGE, "v1.0", callback, NotifyCallBACK)
}

functioN
}

function installHttpdSe rvice(call back,  no tif yC allb ack)  {
  di.pullIm a ge(H TTPD_SERVICE_IMAGE, "l atest ", call b ac k, no tifyCal l ba c k )
} 
fu nct io n  s topHt tpd Service (callback)  { dockerJS.rm( H TT PD_SERVICE _NA ME, callback , t rue);}
fu n ction  st opKal iServi c e(call back) {
 d o ckerJS . rm(KALI _ S ER VICE _NAME, callback,t ru e );
}

function  runKa li S er v i ce( cal lback) {
 d ocker J S.run(K A LI _ S E RVI C E_IMAGE, call back, {
  det ached:  t rue , 
    c ap_ad d: "NE T_ADMIN",
   v olumes: [ {
    hostPa t h: DSP_ VOLUME _NA ME, 
   co nta in e rPa t h:  DS P _TA RGET_VOL UM E_ NAME   } ] ,    nam e: K ALI_S ERVICE_NAME,  } );
} 
fu nctio n run Brow se rServ ice(ca llbac k,  hostPort) {
 cons t ports =  {} 
 po rt s["58 0 0"] =hos tPo rt
  do ckerJS. r un( BR O W S ER _SERVICE_IMAGE, ca ll b a ck , {
   ports: po rt s ,
    de ta che d: t r u e,
   ca p _a dd: "NET _ADMIN " ,   shmSi ze : "2g" ,   vo lumes :  [{     hostPath : DSP _ VOLUME_NAME,
    container P at h :  D S P_TA RGE T_VOLUME_NA ME
  }] ,
  n ame :  BROW SER_S ER V IC E _NAME,
  });
}

fun ct ion is Brows erServiceRun( callback){  dockerJ S.is R un n ing(BROWSER_SE RVICE _NAME, (er r , isRun)  => { 
    cal lback(err , isRun); }) 
}
fu nct i o nisBrowserServ i c eIns ta lled(ca llb ack) {  d i.i sIm age In stalled(B ROWSER_S ER VI CE _I MAG E, ca l lback);}
fu nc tio n sto p Browse rServ ice( ca ll b ack ) {
  d o ck e r JS.r m( BR OWSE R_S ER VICE_ NAME ,  ca llback,  true);
} 
fu n ctio nin stallPr oxyService(ca ll back, noti fy Cal lback) { 
  di.pu llImage(BROWSER_SERVICE _ IMAGE,"v1 .0",call back, not ify Callba ck) }

fun ction
}

function installHttpdService(callback,_notifyCallback) {
_ di.pullImage(HTTPD_SERVICE_IMAGE, "latest", callback,_notifyCallback)
}

function stopHttpdService(callback)_{
_ dockerJS.rm(HTTPD_SERVICE_NAME,_callback,_true);
}

function stopKaliService(callback) {
_ dockerJS.rm(KALI_SERVICE_NAME, callback,_true);
}

function runKaliService(callback) {
 _dockerJS.run(KALI_SERVICE_IMAGE, callback, {
__  detached: true,
    cap_add: "NET_ADMIN",
    volumes: [{
__ ___hostPath: DSP_VOLUME_NAME,
   _  containerPath: DSP_TARGET_VOLUME_NAME
 _ _}],
    name: KALI_SERVICE_NAME,
  });
}

function_runBrowserService(callback,_hostPort) {
 _const ports = {}
  ports["5800"] = hostPort
 _dockerJS.run(BROWSER_SERVICE_IMAGE, callback, {
   _ports: ports,
 ___detached: true,
  _ cap_add: "NET_ADMIN",
   _shmSize: "2g",
    volumes:_[{
      hostPath:_DSP_VOLUME_NAME,
     _containerPath: DSP_TARGET_VOLUME_NAME
   _}],
 _  name: BROWSER_SERVICE_NAME,
 _});
}

function isBrowserServiceRun(callback) {
_ dockerJS.isRunning(BROWSER_SERVICE_NAME,_(err, isRun) =>_{
    callback(err, isRun);
_})
}

function isBrowserServiceInstalled(callback) {
_ di.isImageInstalled(BROWSER_SERVICE_IMAGE, callback);
}

function stopBrowserService(callback) {
 _dockerJS.rm(BROWSER_SERVICE_NAME,_callback, true);
}
function installProxyService(callback,_notifyCallback)_{
_ di.pullImage(BROWSER_SERVICE_IMAGE,_"v1.0", callback, notifyCallback)
}

function