コード例 #1
0
 def exposePort(self, local_port, public_port, scheme):
     keyfile = self.core.getInsecureKeyFile()
     keyfile = inner(keyfile)
     forward_descr = "0.0.0.0:%s:127.0.0.1:%s" % (public_port, local_port)
     engineIP = self.getSSHIP()
     enginePort = str(self.getSSHPort())
     cmdPath = "ssh"
     cmdArgs = [
         "ssh", "-N", "-L", forward_descr, engineIP, "-l", "substance",
         "-p", enginePort, "-o", "StrictHostKeyChecking=no", "-o",
         "UserKnownHostsFile=/dev/null", "-i", keyfile
     ]
     sudo = False
     if public_port < 1024 and not isWithinWindowsSubsystem():
         sudo = True
     self.logAdapter.info(
         "Exposing port %s as %s; kill the process (CTRL-C) to un-expose.",
         local_port, public_port)
     with closing(socket.socket(socket.AF_INET, socket.SOCK_DGRAM)) as s:
         s.connect(("8.8.8.8", 80))
         ip = s.getsockname()[0]
         if scheme:
             self.logAdapter.info("%s://%s:%s is now available.", scheme,
                                  ip, public_port)
         else:
             self.logAdapter.info(
                 "Others can now connect to port %s via IP %s.",
                 public_port, ip)
     Shell.execvp(cmdPath, cmdArgs, {}, sudo=sudo)
コード例 #2
0
ファイル: engine_tests.py プロジェクト: turbulent/substance
    def tearDownClass(cls):
        if cls.engine and cls.engine.isProvisioned():
            cls.engine.deprovision()

        if cls.basePath:
            Shell.nukeDirectory(cls.basePath).catch(cls.raiser)
        if cls.projectsPath:
            Shell.nukeDirectory(cls.projectsPath).catch(cls.raiser)
コード例 #3
0
    def tearDownClass(cls):
        if cls.vmUUID:
            machine.terminate(cls.vmUUID)
            machine.delete(cls.vmUUID)

        if cls.basePath:
            Shell.nukeDirectory(cls.basePath).catch(cls.raiser)
        if cls.projectsPath:
            Shell.nukeDirectory(cls.projectsPath).catch(cls.raiser)
コード例 #4
0
 def remove(self):
     if not os.path.isdir(self.enginePath):
         return Fail(
             FileSystemError("Engine \"%s\" does not exist." % self.name))
     if self.isProvisioned():
         return Fail(
             EngineProvisioned("Engine \"%s\" is provisioned." % self.name))
     return Shell.nukeDirectory(self.enginePath)
コード例 #5
0
ファイル: machine.py プロジェクト: ashouc/substance
def importOVF(importParams, name, ovfFile):
    '''
    Import the OVF file as a virtual box vm.
    '''
    ovfFile = Shell.normalizePath(ovfFile)
    importParams.insert(0, '"' + ovfFile + '"')
    return vboxManager("import", " ".join(importParams)) \
        .then(defer(readMachineID, name))
コード例 #6
0
ファイル: unison.py プロジェクト: ashouc/substance
    def getUnisonArgs(self, direction, path=''):
        folder = self.engine.getEngineFolders()[0]
        localRoot = Shell.normalizePath(os.path.join(folder.hostPath, path))
        remoteRoot = 'ssh://substance@%s/%s/%s' % (
            self.engine.getSSHIP(), folder.guestPath.rstrip('/'),
            path.lstrip('/'))

        # Direction arguments
        if direction == Syncher.UP:
            directionArgs = [
                '-nocreation', localRoot, '-nodeletion', localRoot,
                '-noupdate', localRoot
            ]
        elif direction == Syncher.DOWN:
            directionArgs = [
                '-nocreation', remoteRoot, '-nodeletion', remoteRoot,
                '-noupdate', remoteRoot
            ]
        else:
            directionArgs = ['-prefer', 'newer', '-copyonconflict']

        # User args
        userArgs = folder.syncArgs

        # Other arguments
        rootArgs = [localRoot, remoteRoot]
        ignoreArgs = [
            item for sublist in [['-ignore', 'Name ' + excl]
                                 for excl in folder.excludes]
            for item in sublist
        ]

        # SSH config
        transport = "-p %s -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null" % self.engine.getSSHPort(
        )
        if self.keyfile is not None:
            transport += " -i %s" % Shell.normalizePath(self.keyfile)

        # Assemble everything
        args = ['-batch', '-repeat', 'watch', '-sshargs', transport] + \
            userArgs + directionArgs + ignoreArgs + rootArgs
        if self.ignoreArchives and '-ignorearchives' not in args:
            args.insert(0, '-ignorearchives')
        return args
コード例 #7
0
    def create(self, config=None, profile=None):
        if os.path.isdir(self.enginePath):
            return Fail(EngineExistsError("Engine \"%s\" already exists." % self.name))

        return Shell.makeDirectory(self.enginePath) \
            .then(defer(self.makeDefaultConfig, config=config, profile=profile)) \
            .bind(self.__ensureDevroot) \
            .bind(self.validateConfig) \
            .then(self.config.saveConfig) \
            .bind(dinfo("Generated default engine configuration in %s", self.config.configFile)) \
            .map(self.chainSelf)
コード例 #8
0
 def start(self, direction, path=''):
     self.ensureKeyPerms()
     unisonPath = self.getUnisonBin()
     unisonArgs = self.getUnisonArgs(direction, path)
     unisonEnv = self.getUnisonEnv()
     if self.ignoreArchives:
         # It seems that in certain cases, unison does not observe the -ignorearchives flag correctly
         # So to make sure, we forcibly delete previous archives on both sides
         res = Try.sequence([
             # Delete host archives
             Shell.call(["rm", "-rf", unisonEnv['UNISON']], shell=False),
             # Delete guest archives
             self.engine.readLink().bind(Link.runCommand,
                                         'rm -rf /substance/.unison')
         ])
         if res.isFail():
             return res
     logger.info("Syncing local directory %s to remote directory %s",
                 unisonArgs[-2], unisonArgs[-1])
     logger.debug("EXEC: %s",
                  Shell.stringify([unisonPath] + unisonArgs, unisonEnv))
     os.execve(unisonPath, unisonArgs, unisonEnv)
コード例 #9
0
ファイル: unison.py プロジェクト: ashouc/substance
 def getUnisonEnv(self):
     # Add the unison-fsmonitor binary to PATH
     path = self.getUnisonSupportDirectory() + os.pathsep + os.environ.get(
         'PATH', '')
     # Tell unison to save all replica state to ~/.substance/unison
     unisonDir = Shell.normalizePath(
         os.path.join(self.engine.core.getBasePath(), 'unison'))
     homeDir = os.environ.get('HOME', os.path.expanduser('~'))
     return {
         'UNISON': unisonDir,
         'PATH': path,
         'HOME': homeDir,
         'SSH_AUTH_SOCK': os.environ.get('SSH_AUTH_SOCK', '')
     }
コード例 #10
0
ファイル: box.py プロジェクト: savardc/substance
    def download(self, boxResult):
        archiveURL = boxResult['archiveURL']
        archiveSHA = boxResult['archiveSHA1']
        archive = self.getArchivePath()

        logger.info("Downloading %s:%s (%s)", self.name,
                    self.version, boxResult['archiveURL'])

        return Try.sequence([
            Shell.makeDirectory(os.path.dirname(archive)),
            Try.attempt(streamDownload, url=archiveURL, destination=archive)
            .then(defer(self.verifyArchive, expectedSHA=archiveSHA))
            .then(defer(self.unpackArchive)),
            self.core.getDB().updateBoxRecord(self, boxResult)
        ]).map(lambda x: self)
コード例 #11
0
ファイル: box.py プロジェクト: turbulent/substance
 def unpackArchive(self):
     return Try.sequence([
         Try.attempt(untar, self.getArchivePath(), self.getPath()),
         Shell.rmFile(self.getArchivePath())
     ])
コード例 #12
0
 def __ensureDevroot(self, config):
     devroot = os.path.expanduser(config.get('devroot', {}).get('path'))
     if not os.path.isdir(devroot):
         self.logAdapter.info("Creating devroot at %s" % devroot)
         return Shell.makeDirectory(devroot).then(lambda: OK(config))
     return OK(config)
コード例 #13
0
ファイル: rsync.py プロジェクト: ashouc/substance
 def sync(self):
     op = Shell.call(self.getCommand())
     if op.isFail():
         print("%s" % op)
         return op
     return OK(self)
コード例 #14
0
 def tearDown(self):
     if self.basePath:
         Shell.nukeDirectory(self.basePath).catch(TestCore.raiser)
     if self.projectsPath:
         Shell.nukeDirectory(self.projectsPath).catch(TestCore.raiser)
コード例 #15
0
ファイル: vbox.py プロジェクト: ashouc/substance
def vboxExec(cmd, params=""):
    return Shell.procCommand("%s %s %s" % ("VBoxManage", cmd, params)) \
        .bind(onVboxCommand) \
        .catch(onVboxError)
コード例 #16
0
ファイル: hosts.py プロジェクト: turbulent/substance
 def commitToSystem(self):
     hostsPath = self.determine_hosts_path()
     logger.debug("Commiting '%s' to system '%s'" %
                  (self.hosts_path, hostsPath))
     return Shell.call(["cp", self.hosts_path, self.determine_hosts_path()], shell=False, sudo=True) \
         .then(lambda: os.remove(self.tempFile.name))
コード例 #17
0
ファイル: box.py プロジェクト: turbulent/substance
 def delete(self):
     logger.info("Removing box %s from box cache", self.getShortBoxString())
     return Try.sequence([
         self.core.getDB().removeBoxRecord(self),
         Shell.nukeDirectory(self.getPath())
     ])
コード例 #18
0
ファイル: machine.py プロジェクト: ashouc/substance
def inspectOVF(ovfFile):
    '''
    Inspect an OVF file to extract it's examined output
    '''
    return vboxManager("import", '-n "%s"' % Shell.normalizePath(ovfFile))