plugins {
  id 'org.hidetake.ssh' version 'x.y.z'
}

buildscript {
  repositories {
    jcenter()
  }
  dependencies {
    classpath 'org.hidetake:gradle-ssh-plugin:x.y.z'
  }
}

apply plugin: 'org.hidetake.ssh'

buildscript {
  repositories {
    jcenter()
  }
  dependencies {
    classpath 'org.hidetake:gradle-ssh-plugin:x.y.z'
    classpath 'org.codehaus.groovy:groovy-backports-compat23:2.4.6'
  }
}

apply plugin: 'org.hidetake.ssh'

remotes {
  web01 {
    role 'masterNode'
    host = '192.168.1.101'
    user = 'jenkins'
  }
  web02 {
    host = '192.168.1.102'
    user = 'jenkins'
  }
}

task checkWebServers {
  doLast {
    ssh.run {
      session(remotes.web01) {
        // Execute a command
        def result = execute 'sudo service httpd status'

        // Any Gradle methods or properties are available in a session closure
        copy {
          from "src/main/resources/example"
          into "$buildDir/tmp"
        }

        // Also Groovy methods or properties are available in a session closure
        println result
      }
      session(remotes.web02) {
        def result = execute 'sudo service httpd status'

        // Also Groovy style assertion is available in a session closure
        assert result.contains('running')
      }
    }
  }
}

plugins {
  id 'org.hidetake.ssh' version 'x.y.z'
}

ssh.settings {
  dryRun = project.hasProperty('dryRun')
}

remotes {
  web01 {
    role 'webServers'
    host = '192.168.1.101'
    user = 'jenkins'
    identity = file('id_rsa')
  }
  web02 {
    role 'webServers'
    host = '192.168.1.102'
    user = 'jenkins'
    identity = file('id_rsa')
  }
}

task reload {
  doLast {
    ssh.run {
      session(remotes.role('webServers')) {
        execute 'sudo service tomcat restart'
      }
    }
  }
}

./gradlew reload

java -jar gssh.jar deploy.groovy

ssh.remotes {...}
ssh.run {...}

ssh.run {
  session(ssh.remotes.tester) {
    // Put and execute gssh.jar on the remote server
    put from: ssh.runtime.jar, into: '.'
    execute 'java -jar gssh.jar'
  }
}

@Grab('org.hidetake:groovy-ssh:x.y.z')
@Grab('ch.qos.logback:logback-classic:1.1.2')
def ssh = org.hidetake.groovy.ssh.Ssh.newService()
ssh.remotes {...}
ssh.run {...}

groovy deploy.groovy

ssh.runtime.logback level: 'DEBUG'

compile 'org.hidetake:groovy-ssh:x.y.z'

import org.hidetake.groovy.ssh.Ssh

class App {
  static void main(String[] args) {
    def ssh = Ssh.newService()
    ssh.remotes {...}
    ssh.run {...}
  }
}

ssh.settings {
  knownHosts = allowAnyHosts
  dryRun = true
}

ssh.run {
  settings {
    // overrides global settings
    pty = true
  }
  session(remotes.role('webServers')) {
    execute('sudo service httpd reload')
  }
}

remotes {
  web01 {
    host = '192.168.1.101'
    user = 'jenkins'
    identity = file('id_rsa_jenkins')
    // overrides global settings
    agentForwarding = true
  }
}

execute('sudo service httpd reload', pty: false)
execute('sudo service httpd reload', logging: false)

remotes {
  web01 {
    role('webServers')
    role('servers')
    host = '192.168.1.101'
    user = 'jenkins'
  }
}

// remote hosts associated to servers
session(remotes.role('servers')) {
}

// remote hosts associated to webServer OR appServer
session(remotes.role('webServer', 'appServer')) {
}

// remote hosts associated to webServer AND appServer
session(remotes.allRoles('webServer', 'appServer')) {
}

ssh.settings {
  timeoutSec = 600
}

remotes {
  Gateway {
    host = '10.2.3.4'
    user = 'gwuser'
  }
  Target {
    host = '192.168.1.101'
    user = 'jenkins'
    gateway = remotes.Gateway
  }
}

remotes {
  FrontGateway {
    host = '10.2.3.4'
    user = 'frontgwuser'
  }
  MidGateway {
    host = '172.16.1.2'
    user = 'gwuser'
    gateway = remotes.FrontGateway
  }
  Target {
    host = '192.168.1.101'
    user = 'jenkins'
    gateway = remotes.MidGateway
  }
}

proxies {
  socks01 {
    host = '192.168.1.112'
    port = 1080
    type = SOCKS
  }
}

proxies {
  socks {
    host = '192.168.1.112'
    port = 1080
    user = 'admin'
    password = '0t1s'
    type = SOCKS
    socksVersion = 5
  }

  http {
    host = '192.168.1.113'
    port = 8080
    type = HTTP
  }
}

remotes {
  web01 {
    host = '192.168.1.101'
    user = 'jenkins'
    proxy = proxies.http
  }

  web02 {
    host = '192.168.1.102'
    user = 'jenkins'
    proxy = proxies.socks
  }
}

ssh.settings {
  // All remotes will use this proxy by default.
  // Each remote can override this configuration.
  proxy = proxies.socks01
}

task jarSearch {
  doLast {
    ssh.run {
      settings {
        proxy = proxies.http01
      }
      session(remotes.role('mavenRepo')) { ... }
    }
  }
}

task setupRemote {
  doLast {
    ssh.run {
      session(remotes.web01) {
        def targetHost = execute 'cat settings/hostname'
        def targetUser = execute 'cat settings/username'
        // Create and add a remote host
        remotes.create('db01') {
          host = targetHost
          user = targetUser
        }
      }
    }
  }
}

task something(dependsOn: setupRemote) {
  doLast {
    ssh.run {
      session(remotes.db01) {
        //execute ...
      }
    }
  }
}

def result = ssh.run {
  session(remotes.web01) {
    'result1'
  }
}
assert result == 'result1'

def results = ssh.run {
  session(remotes.web01) {
    'result1'
  }
  session(remotes.web02) {
    'result2'
  }
}
assert results == ['result1', 'result2']

task syncKernelParam {
  doLast {
    def paramKey = 'net.core.wmem_max'
    def paramValue = ssh.run {
      session(remotes.web01) {
        execute("sysctl '$paramKey' | sed -e 's/ //g'")
      }
    }
    assert paramValue.contains(paramKey)
    ssh.run {
      session(remotes.web02) {
        execute("sysctl -w '$paramValue'")
      }
    }
  }
}

ssh.run {
  session(remotes.web01) {
    execute 'false'
  }
} (1)

ssh.run {
  session(remotes.web01) {
    execute 'false'  (1)
  }
  session(remotes.web02) {
    execute 'true'  (2)
  }
} (3)

ssh.runInOrder {
  session(remotes.web01) {
    execute 'false'  (1)
  }
  session(remotes.web02) {
    execute 'true'  (2)
  }
} (3)

session(remotes.web01) {
  //execute ...
}

// give a list of remote hosts
session([remotes.web01, remotes.web02]) {
}

// give remote hosts as arguments
session(remotes.web01, remotes.web02) {
}

// enumerate sessions
session(remotes.web01) {
}
session(remotes.web02) {
}

session(name: 'web01', host: '192.168.1.101', user: 'jenkins', identity: file('id_rsa')) {
}

// If name is not given, auto-generated name such as Remote1 is shown in console log
session(host: '192.168.1.101', user: 'jenkins', identity: file('id_rsa')) {
}

execute 'sudo service httpd reload'

// with settings
execute 'sudo service httpd reload', pty: true

execute(['perl', '-e', /print 'current: ', time, "\n"/])

def result = execute 'uname -a'
println result

execute('uname -a') { result ->
  println result
}

execute 'exit 1', ignoreError: true

executeSudo 'service httpd reload'

// also can be called with settings
executeSudo 'service httpd reload', pty: true

def result = executeSudo 'service httpd status'
println result

executeSudo(['perl', '-e', /print 'current: ', time, "\n"/])

executeSudo('service httpd status') { result ->
  println result
}

session(remotes.web01) {
  shell interaction: {
    when(partial: ~/.*$/) {
      standardInput << 'exit 0' << '\n'
    }
  }
}

shell ignoreError: true, interaction: {...}

// execute a script
executeScript '''#!/bin/sh
echo "Hello World!"
'''

// execute a script from local file
executeScript file('deploy.sh')

// execute a script with settings
executeScript '''#!/bin/sh
echo "Hello World!"
''', pty: true

def result = executeScript '''#!/bin/sh
echo "Hello World!"
'''
println result

executeScript('''#!/bin/sh
echo "Hello World!"
''') { result ->
  println result
}

// get a file or directory
get from: '/remote/file', into: 'local_file'
get from: '/remote/file', into: buildDir

// get files by a file filter
get from: '/remote/folder', into: buildDir, filter: { it.name =~ /\.xml$/ }

// get content as an output stream
file.withOutputStream { stream ->
  get from: '/remote/file', into: stream
}

// get content as a string
def text = get from: '/remote/file'

// put a file or directory
put from: 'local_file', into: '/remote/file'
put from: file('fixture.dat'), into: '/remote/folder'
put from: buildDir, into: '/remote/folder'

// put files
put from: files('local_file1', 'local_file2'), into: '/remote/folder'

// put content from an input stream
file.withInputStream { stream ->
  put from: stream, into: '/remote/file.txt'
}

// put content from a string
put text: '''#!/bin/sh
echo 'hello world'
''', into: '/remote/script.sh'

// put content from a byte array
put bytes: [0xff, 0xff], into: '/remote/fixture.dat'

// put files by a file filter
put from: buildDir, into: '/remote/folder', filter: { it.name =~ /\.xml$/ }

// specify a file
remove '/remote/file'

// specify a directory to remove recursively
remove '/remote/directory'

// specify more paths
remove '/remote/file', '/remote/directory'

// Forward localhost:18080 to remote:8080
forwardLocalPort port: 18080, hostPort: 8080

// Forward localhost:(allocated port) to remote:8080
int port = forwardLocalPort hostPort: 8080

// Forward localhost:18080 to 172.16.1.1:8080
forwardLocalPort port: 18080, host: '172.16.1.1', hostPort: 8080

// Forward *:18080 (listen to all) to 172.16.1.1:8080
forwardLocalPort bind: '0.0.0.0', port: 18080, host: '172.16.1.1', hostPort: 8080

// Forward remote:30000 to localhost:8080
forwardRemotePort port: 30000, hostPort: 8080

// Forward remote:30000 to 192.168.1.5:8080
forwardRemotePort port: 30000, host: '192.168.1.5', hostPort: 8080

// Forward remote:30000 (listen to all) to 192.168.1.5:8080
forwardRemotePort bind: '0.0.0.0', port: 30000, host: '192.168.1.5', hostPort: 8080

import groovyx.net.http.RESTClient

ssh.run {
  session(remotes.web01) {
    forwardLocalPort port: 8080, hostPort: 8080

    // access to the HTTP server via the tunnel
    new RESTClient('http://localhost:8080').get(path: '/')
  }
}

ssh.settings {
  extensions.add restartAppServer: {
    execute 'sudo service tomcat restart'
  }
}

ssh.run {
  session(ssh.remotes.testServer) {
    restartAppServer()
  }
}

repositories {
  jcenter()
}

configurations {
  groovyRuntime
}

dependencies {
  groovyRuntime 'org.codehaus.groovy:groovy-all:2.5.6'
}

ssh.settings {
  /**
   * Execute a Groovy script on the remote host.
   * Groovy dependency must be set as the configuration groovyRuntime.
   */
  extensions.add executeGroovyScript: { String script ->
    def temporaryPath = "/tmp/${UUID.randomUUID()}"
    try {
      execute "mkdir -vp $temporaryPath"
      put from: project.configurations.groovyRuntime, into: temporaryPath
      put text: script, into: "$temporaryPath/script.groovy"
      execute "java -jar $temporaryPath/groovy-all-*.jar $temporaryPath/script.groovy"
    } finally {
      execute "rm -vfr $temporaryPath"
    }
  }
}

task example {
  doLast {
    ssh.run {
      session(remotes.webServer) {
        // Execute a script on the remote host
        executeGroovyScript 'println GroovySystem.version'
      }
    }
  }
}

// buildSrc/src/main/groovy/extensions.groovy
trait RemoteFileExtension {
  void eachFile(String directory, Closure closure) {
    sftp {
      ls(directory).each(closure)
    }
  }
}

// build.gradle
ssh.run {
  settings {
    extensions.add RemoteFileExtension
  }
  session(remotes.localhost) {
    eachFile('/webapps') {
      println it.filename
    }
  }
}

task example << {
  // FIXME: sshexec is no longer supported
  sshexec {
    session(...) {...}
  }

  // use ssh.run instead
  ssh.run {
    session(...) {...}
  }
}

// FIXME: ssh is no longer supported
ssh {
  knownHosts = allowAnyHosts
}

// use ssh.settings instead
ssh.settings {
  knownHosts = allowAnyHosts
}