Como executo um comando de terminal em um script Swift? (por exemplo, xcodebuild)

Question 1

Quero substituir meus scripts de bash de CI por swift. Não consigo descobrir como invocar um comando de terminal normal, como lsouxcodebuild

#!/usr/bin/env xcrun swift

import Foundation // Works
println("Test") // Works
ls // Fails
xcodebuild -workspace myApp.xcworkspace // Fails

$ ./script.swift
./script.swift:5:1: error: use of unresolved identifier 'ls'
ls // Fails
^
... etc ....

Question 2

Se você não usar saídas de comando no código Swift, o seguinte seria suficiente:

#!/usr/bin/env swift

import Foundation

@discardableResult
func shell(_ args: String...) -> Int32 {
    let task = Process()
    task.launchPath = "/usr/bin/env"
    task.arguments = args
    task.launch()
    task.waitUntilExit()
    return task.terminationStatus
}

shell("ls")
shell("xcodebuild", "-workspace", "myApp.xcworkspace")

Atualizado: para Swift3 / Xcode8

Question 3

Se você gostaria de usar argumentos de linha de comando "exatamente" como faria na linha de comando (sem separar todos os argumentos), tente o seguinte.

(Esta resposta melhora a resposta da LegoLess e pode ser usada no Swift 5)

import Foundation

func shell(_ command: String) -> String {
    let task = Process()
    let pipe = Pipe()

    task.standardOutput = pipe
    task.arguments = ["-c", command]
    task.launchPath = "/bin/bash"
    task.launch()

    let data = pipe.fileHandleForReading.readDataToEndOfFile()
    let output = String(data: data, encoding: .utf8)!

    return output
}

// Example usage:
shell("ls -la")

Question 4

O problema aqui é que você não pode misturar e combinar Bash e Swift. Você já sabe como executar o script Swift na linha de comando, agora você precisa adicionar os métodos para executar comandos do Shell no Swift. Em resumo do blog PracticalSwift :

func shell(launchPath: String, arguments: [String]) -> String?
{
    let task = Process()
    task.launchPath = launchPath
    task.arguments = arguments

    let pipe = Pipe()
    task.standardOutput = pipe
    task.launch()

    let data = pipe.fileHandleForReading.readDataToEndOfFile()
    let output = String(data: data, encoding: String.Encoding.utf8)

    return output
}

O código Swift a seguir será executado xcodebuildcom argumentos e, em seguida, produzirá o resultado.

shell("xcodebuild", ["-workspace", "myApp.xcworkspace"]);

Quanto à pesquisa do conteúdo do diretório (que é o que lsfaz no Bash), sugiro usar NSFileManagere escanear o diretório diretamente no Swift, em vez da saída do Bash, o que pode ser difícil de analisar.

Question 5

Função de utilidade em Swift 3.0

Isso também retorna o status de encerramento das tarefas e aguarda a conclusão.

func shell(launchPath: String, arguments: [String] = []) -> (String? , Int32) {
    let task = Process()
    task.launchPath = launchPath
    task.arguments = arguments

    let pipe = Pipe()
    task.standardOutput = pipe
    task.standardError = pipe
    task.launch()
    let data = pipe.fileHandleForReading.readDataToEndOfFile()
    let output = String(data: data, encoding: .utf8)
    task.waitUntilExit()
    return (output, task.terminationStatus)
}

Question 6

Se você gostaria de usar o ambiente bash para chamar comandos, use a seguinte função bash que usa uma versão corrigida do Legoless. Tive que remover uma nova linha final do resultado da função do shell.

Swift 3.0: (Xcode8)

import Foundation

func shell(launchPath: String, arguments: [String]) -> String
{
    let task = Process()
    task.launchPath = launchPath
    task.arguments = arguments

    let pipe = Pipe()
    task.standardOutput = pipe
    task.launch()

    let data = pipe.fileHandleForReading.readDataToEndOfFile()
    let output = String(data: data, encoding: String.Encoding.utf8)!
    if output.characters.count > 0 {
        //remove newline character.
        let lastIndex = output.index(before: output.endIndex)
        return output[output.startIndex ..< lastIndex]
    }
    return output
}

func bash(command: String, arguments: [String]) -> String {
    let whichPathForCommand = shell(launchPath: "/bin/bash", arguments: [ "-l", "-c", "which \(command)" ])
    return shell(launchPath: whichPathForCommand, arguments: arguments)
}

Por exemplo, para obter o branch git de trabalho atual do diretório de trabalho atual:

let currentBranch = bash("git", arguments: ["describe", "--contains", "--all", "HEAD"])
print("current branch:\(currentBranch)")

Question 7

Roteiro completo baseado na resposta de Legoless

#!/usr/bin/env swift

import Foundation

func printShell(launchPath: String, arguments: [String] = []) {
    let output = shell(launchPath: launchPath, arguments: arguments)

    if (output != nil) {
        print(output!)
    }
}

func shell(launchPath: String, arguments: [String] = []) -> String? {
    let task = Process()
    task.launchPath = launchPath
    task.arguments = arguments

    let pipe = Pipe()
    task.standardOutput = pipe
    task.launch()

    let data = pipe.fileHandleForReading.readDataToEndOfFile()
    let output = String(data: data, encoding: String.Encoding.utf8)

    return output
}

// > ls
// > ls -a -g
printShell(launchPath: "/bin/ls")
printShell(launchPath: "/bin/ls", arguments:["-a", "-g"])

Question 8

Apenas para atualizar isso, já que a Apple tornou .launchPath e launch () obsoletos, aqui está uma função de utilitário atualizada para Swift 4 que deve ser um pouco mais preparada para o futuro.

Observação: a documentação da Apple sobre as substituições ( run () , executableURL , etc) está basicamente vazia neste ponto.

import Foundation

// wrapper function for shell commands
// must provide full path to executable
func shell(_ launchPath: String, _ arguments: [String] = []) -> (String?, Int32) {
  let task = Process()
  task.executableURL = URL(fileURLWithPath: launchPath)
  task.arguments = arguments

  let pipe = Pipe()
  task.standardOutput = pipe
  task.standardError = pipe

  do {
    try task.run()
  } catch {
    // handle errors
    print("Error: \(error.localizedDescription)")
  }

  let data = pipe.fileHandleForReading.readDataToEndOfFile()
  let output = String(data: data, encoding: .utf8)

  task.waitUntilExit()
  return (output, task.terminationStatus)
}


// valid directory listing test
let (goodOutput, goodStatus) = shell("/bin/ls", ["-la"])
if let out = goodOutput { print("\(out)") }
print("Returned \(goodStatus)\n")

// invalid test
let (badOutput, badStatus) = shell("ls")

Deve ser capaz de colar isso diretamente em um playground para vê-lo em ação.

Question 9

Atualizando para Swift 4.0 (lidando com mudanças em String)

func shell(launchPath: String, arguments: [String]) -> String
{
    let task = Process()
    task.launchPath = launchPath
    task.arguments = arguments

    let pipe = Pipe()
    task.standardOutput = pipe
    task.launch()

    let data = pipe.fileHandleForReading.readDataToEndOfFile()
    let output = String(data: data, encoding: String.Encoding.utf8)!
    if output.count > 0 {
        //remove newline character.
        let lastIndex = output.index(before: output.endIndex)
        return String(output[output.startIndex ..< lastIndex])
    }
    return output
}

func bash(command: String, arguments: [String]) -> String {
    let whichPathForCommand = shell(launchPath: "/bin/bash", arguments: [ "-l", "-c", "which \(command)" ])
    return shell(launchPath: whichPathForCommand, arguments: arguments)
}

Question 10

Depois de tentar algumas das soluções postadas aqui, descobri que a melhor maneira de executar comandos era usando o -csinalizador para os argumentos.

@discardableResult func shell(_ command: String) -> (String?, Int32) {
    let task = Process()

    task.launchPath = "/bin/bash"
    task.arguments = ["-c", command]

    let pipe = Pipe()
    task.standardOutput = pipe
    task.standardError = pipe
    task.launch()

    let data = pipe.fileHandleForReading.readDataToEndOfFile()
    let output = String(data: data, encoding: .utf8)
    task.waitUntilExit()
    return (output, task.terminationStatus)
}


let _ = shell("mkdir ~/Desktop/test")

Question 11

Misturando as respostas de Rintaro e Legoless para Swift 3

@discardableResult
func shell(_ args: String...) -> String {
    let task = Process()
    task.launchPath = "/usr/bin/env"
    task.arguments = args

    let pipe = Pipe()
    task.standardOutput = pipe

    task.launch()
    task.waitUntilExit()

    let data = pipe.fileHandleForReading.readDataToEndOfFile()

    guard let output: String = String(data: data, encoding: .utf8) else {
        return ""
    }
    return output
}

Question 12

Pequena melhoria com o suporte para variáveis env:

func shell(launchPath: String,
           arguments: [String] = [],
           environment: [String : String]? = nil) -> (String , Int32) {
    let task = Process()
    task.launchPath = launchPath
    task.arguments = arguments
    if let environment = environment {
        task.environment = environment
    }

    let pipe = Pipe()
    task.standardOutput = pipe
    task.standardError = pipe
    task.launch()
    let data = pipe.fileHandleForReading.readDataToEndOfFile()
    let output = String(data: data, encoding: .utf8) ?? ""
    task.waitUntilExit()
    return (output, task.terminationStatus)
}

Question 13

Exemplo de uso da classe Process para executar um script Python.

Além disso:

 - added basic exception handling
 - setting environment variables (in my case I had to do it to get Google SDK to authenticate correctly)
 - arguments 







 import Cocoa

func shellTask(_ url: URL, arguments:[String], environment:[String : String]) throws ->(String?, String?){
   let task = Process()
   task.executableURL = url
   task.arguments =  arguments
   task.environment = environment

   let outputPipe = Pipe()
   let errorPipe = Pipe()

   task.standardOutput = outputPipe
   task.standardError = errorPipe
   try task.run()

   let outputData = outputPipe.fileHandleForReading.readDataToEndOfFile()
   let errorData = errorPipe.fileHandleForReading.readDataToEndOfFile()

   let output = String(decoding: outputData, as: UTF8.self)
   let error = String(decoding: errorData, as: UTF8.self)

   return (output,error)
}

func pythonUploadTask()
{
   let url = URL(fileURLWithPath: "/usr/bin/python")
   let pythonScript =  "upload.py"

   let fileToUpload = "/CuteCat.mp4"
   let arguments = [pythonScript,fileToUpload]
   var environment = ProcessInfo.processInfo.environment
   environment["PATH"]="usr/local/bin"
   environment["GOOGLE_APPLICATION_CREDENTIALS"] = "/Users/j.chudzynski/GoogleCredentials/credentials.json"
   do {
      let result = try shellTask(url, arguments: arguments, environment: environment)
      if let output = result.0
      {
         print(output)
      }
      if let output = result.1
      {
         print(output)
      }

   } catch  {
      print("Unexpected error:\(error)")
   }
}

Question 14

Eu construí SwiftExec , uma pequena biblioteca para a execução de tais comandos:

import SwiftExec

var result: ExecResult
do {
    result = try exec(program: "/usr/bin/git", arguments: ["status"])
} catch {
    let error = error as! ExecError
    result = error.execResult
}

print(result.exitCode!)
print(result.stdout!)
print(result.stderr!)

É uma biblioteca de arquivo único que pode ser facilmente copiada e colada em projetos ou instalada usando SPM. É testado e simplifica o tratamento de erros.

Há também ShellOut , que também oferece suporte a uma variedade de comandos predefinidos.

Answer 1

Quero substituir meus scripts de bash de CI por swift. Não consigo descobrir como invocar um comando de terminal normal, como lsouxcodebuild

#!/usr/bin/env xcrun swift

import Foundation // Works
println("Test") // Works
ls // Fails
xcodebuild -workspace myApp.xcworkspace // Fails

$ ./script.swift
./script.swift:5:1: error: use of unresolved identifier 'ls'
ls // Fails
^
... etc ....

Answer 2

136

Se você não usar saídas de comando no código Swift, o seguinte seria suficiente:

#!/usr/bin/env swift

import Foundation

@discardableResult
func shell(_ args: String...) -> Int32 {
    let task = Process()
    task.launchPath = "/usr/bin/env"
    task.arguments = args
    task.launch()
    task.waitUntilExit()
    return task.terminationStatus
}

shell("ls")
shell("xcodebuild", "-workspace", "myApp.xcworkspace")

Atualizado: para Swift3 / Xcode8

Rintaro
fonte

3

'NSTask' foi renomeado para 'Processo'

Mateusz

4

O processo () ainda está no Swift 4? Estou recebendo um símbolo indefinido. : /

Arnaldo Capo

1

@ArnaldoCapo Ainda funciona bem para mim! Aqui está um exemplo:

#!/usr/bin/env swift  import Foundation  @discardableResult func shell(_ args: String...) -> Int32 {     let task = Process()     task.launchPath = "/usr/bin/env"     task.arguments = args     task.launch()     task.waitUntilExit()     return task.terminationStatus }  shell("ls")

CorPruijs 05 de

2

Tentei que consegui: Tentei que consegui: i.imgur.com/Ge1OOCG.png

cyber8200

4

O processo está disponível apenas no macOS

shallowThought

Answer 3

3

'NSTask' foi renomeado para 'Processo'

Mateusz

Answer 4

4

O processo () ainda está no Swift 4? Estou recebendo um símbolo indefinido. : /

Arnaldo Capo

Answer 5

1

@ArnaldoCapo Ainda funciona bem para mim! Aqui está um exemplo:

#!/usr/bin/env swift  import Foundation  @discardableResult func shell(_ args: String...) -> Int32 {     let task = Process()     task.launchPath = "/usr/bin/env"     task.arguments = args     task.launch()     task.waitUntilExit()     return task.terminationStatus }  shell("ls")

CorPruijs 05 de

Answer 6

2

Tentei que consegui: Tentei que consegui: i.imgur.com/Ge1OOCG.png

cyber8200

Answer 7

4

O processo está disponível apenas no macOS

shallowThought

Answer 8

85

Se você gostaria de usar argumentos de linha de comando "exatamente" como faria na linha de comando (sem separar todos os argumentos), tente o seguinte.

(Esta resposta melhora a resposta da LegoLess e pode ser usada no Swift 5)

import Foundation

func shell(_ command: String) -> String {
    let task = Process()
    let pipe = Pipe()

    task.standardOutput = pipe
    task.arguments = ["-c", command]
    task.launchPath = "/bin/bash"
    task.launch()

    let data = pipe.fileHandleForReading.readDataToEndOfFile()
    let output = String(data: data, encoding: .utf8)!

    return output
}

// Example usage:
shell("ls -la")

user3064009
fonte

6

Essa resposta deve ser muito mais elevada, pois resolve muitos dos problemas das anteriores.

Steven Hepting

1

+1. Deve ser observado para usuários de osx que /bin/bashse refere a bash-3.2. Se você quiser usar os recursos mais avançados do bash, altere o caminho ( /usr/bin/env bashgeralmente é uma boa alternativa)

Aserre

Alguém pode ajudar com isso? Argumentos não passam stackoverflow.com/questions/62203978/…

mahdi

Answer 9

6

Essa resposta deve ser muito mais elevada, pois resolve muitos dos problemas das anteriores.

Steven Hepting

Answer 10

1

+1. Deve ser observado para usuários de osx que /bin/bashse refere a bash-3.2. Se você quiser usar os recursos mais avançados do bash, altere o caminho ( /usr/bin/env bashgeralmente é uma boa alternativa)

Aserre

Answer 11

Alguém pode ajudar com isso? Argumentos não passam stackoverflow.com/questions/62203978/…

mahdi

Answer 12

34

O problema aqui é que você não pode misturar e combinar Bash e Swift. Você já sabe como executar o script Swift na linha de comando, agora você precisa adicionar os métodos para executar comandos do Shell no Swift. Em resumo do blog PracticalSwift :

func shell(launchPath: String, arguments: [String]) -> String?
{
    let task = Process()
    task.launchPath = launchPath
    task.arguments = arguments

    let pipe = Pipe()
    task.standardOutput = pipe
    task.launch()

    let data = pipe.fileHandleForReading.readDataToEndOfFile()
    let output = String(data: data, encoding: String.Encoding.utf8)

    return output
}

O código Swift a seguir será executado xcodebuildcom argumentos e, em seguida, produzirá o resultado.

shell("xcodebuild", ["-workspace", "myApp.xcworkspace"]);

Quanto à pesquisa do conteúdo do diretório (que é o que lsfaz no Bash), sugiro usar NSFileManagere escanear o diretório diretamente no Swift, em vez da saída do Bash, o que pode ser difícil de analisar.

Sem legol
fonte

1

Ótimo - fiz algumas edições para fazer essa compilação, mas estou recebendo uma exceção de tempo de execução ao tentar invocar shell("ls", [])- 'NSInvalidArgumentException', reason: 'launch path not accessible' Alguma ideia?

Robert

5

NSTask não pesquisa o executável (usando seu PATH do ambiente) como o shell faz. O caminho de inicialização deve ser um caminho absoluto (por exemplo, "/ bin / ls") ou um caminho relativo ao diretório de trabalho atual.

Martin R

stackoverflow.com/questions/386783/… PATH é basicamente um conceito de shell e não pode ser alcançado.

Legoless de

Ótimo - agora funciona. Publiquei o script completo + algumas modificações para ser completo. Obrigado.

Robert

2

Usando o shell ("cd", "~ / Desktop /"), obtenho: / usr / bin / cd: linha 4: cd: ~ / Desktop /: Não existe esse arquivo ou diretório

Zaporozhchenko Oleksandr

Answer 13

1

Ótimo - fiz algumas edições para fazer essa compilação, mas estou recebendo uma exceção de tempo de execução ao tentar invocar shell("ls", [])- 'NSInvalidArgumentException', reason: 'launch path not accessible' Alguma ideia?

Robert

Answer 14

5

NSTask não pesquisa o executável (usando seu PATH do ambiente) como o shell faz. O caminho de inicialização deve ser um caminho absoluto (por exemplo, "/ bin / ls") ou um caminho relativo ao diretório de trabalho atual.

Martin R

Answer 15

stackoverflow.com/questions/386783/… PATH é basicamente um conceito de shell e não pode ser alcançado.

Legoless de

Answer 16

Ótimo - agora funciona. Publiquei o script completo + algumas modificações para ser completo. Obrigado.

Robert

Answer 17

2

Usando o shell ("cd", "~ / Desktop /"), obtenho: / usr / bin / cd: linha 4: cd: ~ / Desktop /: Não existe esse arquivo ou diretório

Zaporozhchenko Oleksandr

Answer 18

Função de utilidade em Swift 3.0

Isso também retorna o status de encerramento das tarefas e aguarda a conclusão.

func shell(launchPath: String, arguments: [String] = []) -> (String? , Int32) {
    let task = Process()
    task.launchPath = launchPath
    task.arguments = arguments

    let pipe = Pipe()
    task.standardOutput = pipe
    task.standardError = pipe
    task.launch()
    let data = pipe.fileHandleForReading.readDataToEndOfFile()
    let output = String(data: data, encoding: .utf8)
    task.waitUntilExit()
    return (output, task.terminationStatus)
}

Answer 19

5

import Foundationausente

Binarian

Answer 20

3

Infelizmente, não para iOS.

Raphael

Answer 21

Se você gostaria de usar o ambiente bash para chamar comandos, use a seguinte função bash que usa uma versão corrigida do Legoless. Tive que remover uma nova linha final do resultado da função do shell.

Swift 3.0: (Xcode8)

import Foundation

func shell(launchPath: String, arguments: [String]) -> String
{
    let task = Process()
    task.launchPath = launchPath
    task.arguments = arguments

    let pipe = Pipe()
    task.standardOutput = pipe
    task.launch()

    let data = pipe.fileHandleForReading.readDataToEndOfFile()
    let output = String(data: data, encoding: String.Encoding.utf8)!
    if output.characters.count > 0 {
        //remove newline character.
        let lastIndex = output.index(before: output.endIndex)
        return output[output.startIndex ..< lastIndex]
    }
    return output
}

func bash(command: String, arguments: [String]) -> String {
    let whichPathForCommand = shell(launchPath: "/bin/bash", arguments: [ "-l", "-c", "which \(command)" ])
    return shell(launchPath: whichPathForCommand, arguments: arguments)
}

Por exemplo, para obter o branch git de trabalho atual do diretório de trabalho atual:

let currentBranch = bash("git", arguments: ["describe", "--contains", "--all", "HEAD"])
print("current branch:\(currentBranch)")

Answer 22

Roteiro completo baseado na resposta de Legoless

#!/usr/bin/env swift

import Foundation

func printShell(launchPath: String, arguments: [String] = []) {
    let output = shell(launchPath: launchPath, arguments: arguments)

    if (output != nil) {
        print(output!)
    }
}

func shell(launchPath: String, arguments: [String] = []) -> String? {
    let task = Process()
    task.launchPath = launchPath
    task.arguments = arguments

    let pipe = Pipe()
    task.standardOutput = pipe
    task.launch()

    let data = pipe.fileHandleForReading.readDataToEndOfFile()
    let output = String(data: data, encoding: String.Encoding.utf8)

    return output
}

// > ls
// > ls -a -g
printShell(launchPath: "/bin/ls")
printShell(launchPath: "/bin/ls", arguments:["-a", "-g"])

Answer 23

Apenas para atualizar isso, já que a Apple tornou .launchPath e launch () obsoletos, aqui está uma função de utilitário atualizada para Swift 4 que deve ser um pouco mais preparada para o futuro.

Observação: a documentação da Apple sobre as substituições ( run () , executableURL , etc) está basicamente vazia neste ponto.

import Foundation

// wrapper function for shell commands
// must provide full path to executable
func shell(_ launchPath: String, _ arguments: [String] = []) -> (String?, Int32) {
  let task = Process()
  task.executableURL = URL(fileURLWithPath: launchPath)
  task.arguments = arguments

  let pipe = Pipe()
  task.standardOutput = pipe
  task.standardError = pipe

  do {
    try task.run()
  } catch {
    // handle errors
    print("Error: \(error.localizedDescription)")
  }

  let data = pipe.fileHandleForReading.readDataToEndOfFile()
  let output = String(data: data, encoding: .utf8)

  task.waitUntilExit()
  return (output, task.terminationStatus)
}


// valid directory listing test
let (goodOutput, goodStatus) = shell("/bin/ls", ["-la"])
if let out = goodOutput { print("\(out)") }
print("Returned \(goodStatus)\n")

// invalid test
let (badOutput, badStatus) = shell("ls")

Deve ser capaz de colar isso diretamente em um playground para vê-lo em ação.

Answer 24

Atualizando para Swift 4.0 (lidando com mudanças em String)

func shell(launchPath: String, arguments: [String]) -> String
{
    let task = Process()
    task.launchPath = launchPath
    task.arguments = arguments

    let pipe = Pipe()
    task.standardOutput = pipe
    task.launch()

    let data = pipe.fileHandleForReading.readDataToEndOfFile()
    let output = String(data: data, encoding: String.Encoding.utf8)!
    if output.count > 0 {
        //remove newline character.
        let lastIndex = output.index(before: output.endIndex)
        return String(output[output.startIndex ..< lastIndex])
    }
    return output
}

func bash(command: String, arguments: [String]) -> String {
    let whichPathForCommand = shell(launchPath: "/bin/bash", arguments: [ "-l", "-c", "which \(command)" ])
    return shell(launchPath: whichPathForCommand, arguments: arguments)
}

Answer 25

dê o exemplo

Gowtham Sooryaraj

Answer 26

Depois de tentar algumas das soluções postadas aqui, descobri que a melhor maneira de executar comandos era usando o -csinalizador para os argumentos.

@discardableResult func shell(_ command: String) -> (String?, Int32) {
    let task = Process()

    task.launchPath = "/bin/bash"
    task.arguments = ["-c", command]

    let pipe = Pipe()
    task.standardOutput = pipe
    task.standardError = pipe
    task.launch()

    let data = pipe.fileHandleForReading.readDataToEndOfFile()
    let output = String(data: data, encoding: .utf8)
    task.waitUntilExit()
    return (output, task.terminationStatus)
}


let _ = shell("mkdir ~/Desktop/test")

Answer 27

Misturando as respostas de Rintaro e Legoless para Swift 3

@discardableResult
func shell(_ args: String...) -> String {
    let task = Process()
    task.launchPath = "/usr/bin/env"
    task.arguments = args

    let pipe = Pipe()
    task.standardOutput = pipe

    task.launch()
    task.waitUntilExit()

    let data = pipe.fileHandleForReading.readDataToEndOfFile()

    guard let output: String = String(data: data, encoding: .utf8) else {
        return ""
    }
    return output
}

Answer 28

Pequena melhoria com o suporte para variáveis env:

func shell(launchPath: String,
           arguments: [String] = [],
           environment: [String : String]? = nil) -> (String , Int32) {
    let task = Process()
    task.launchPath = launchPath
    task.arguments = arguments
    if let environment = environment {
        task.environment = environment
    }

    let pipe = Pipe()
    task.standardOutput = pipe
    task.standardError = pipe
    task.launch()
    let data = pipe.fileHandleForReading.readDataToEndOfFile()
    let output = String(data: data, encoding: .utf8) ?? ""
    task.waitUntilExit()
    return (output, task.terminationStatus)
}

Answer 29

Exemplo de uso da classe Process para executar um script Python.

Além disso:

 - added basic exception handling
 - setting environment variables (in my case I had to do it to get Google SDK to authenticate correctly)
 - arguments 







 import Cocoa

func shellTask(_ url: URL, arguments:[String], environment:[String : String]) throws ->(String?, String?){
   let task = Process()
   task.executableURL = url
   task.arguments =  arguments
   task.environment = environment

   let outputPipe = Pipe()
   let errorPipe = Pipe()

   task.standardOutput = outputPipe
   task.standardError = errorPipe
   try task.run()

   let outputData = outputPipe.fileHandleForReading.readDataToEndOfFile()
   let errorData = errorPipe.fileHandleForReading.readDataToEndOfFile()

   let output = String(decoding: outputData, as: UTF8.self)
   let error = String(decoding: errorData, as: UTF8.self)

   return (output,error)
}

func pythonUploadTask()
{
   let url = URL(fileURLWithPath: "/usr/bin/python")
   let pythonScript =  "upload.py"

   let fileToUpload = "/CuteCat.mp4"
   let arguments = [pythonScript,fileToUpload]
   var environment = ProcessInfo.processInfo.environment
   environment["PATH"]="usr/local/bin"
   environment["GOOGLE_APPLICATION_CREDENTIALS"] = "/Users/j.chudzynski/GoogleCredentials/credentials.json"
   do {
      let result = try shellTask(url, arguments: arguments, environment: environment)
      if let output = result.0
      {
         print(output)
      }
      if let output = result.1
      {
         print(output)
      }

   } catch  {
      print("Unexpected error:\(error)")
   }
}

Answer 30

onde você coloca o arquivo "upload.py '

Suhaib Roomy

Answer 31

Eu construí SwiftExec , uma pequena biblioteca para a execução de tais comandos:

import SwiftExec

var result: ExecResult
do {
    result = try exec(program: "/usr/bin/git", arguments: ["status"])
} catch {
    let error = error as! ExecError
    result = error.execResult
}

print(result.exitCode!)
print(result.stdout!)
print(result.stderr!)

É uma biblioteca de arquivo único que pode ser facilmente copiada e colada em projetos ou instalada usando SPM. É testado e simplifica o tratamento de erros.

Há também ShellOut , que também oferece suporte a uma variedade de comandos predefinidos.

Como executo um comando de terminal em um script Swift? (por exemplo, xcodebuild)

Respostas: