swift-playground-action/swift3Action/spm-build/_Whisk.swift - openwhisk-xcode - Git at Google

 /*
  * Copyright 2015-2016 IBM Corporation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 import Foundation
 import KituraNet
 import Dispatch

 class Whisk {
     class func invoke(actionNamed action : String, withParameters params : [String:Any], blocking: Bool = true) -> [String:Any] {
         let parsedAction = parseQualifiedName(name: action)
         let strBlocking = blocking ? "true" : "false"
         let path = "/api/v1/namespaces/\(parsedAction.namespace)/actions/\(parsedAction.name)?blocking=\(strBlocking)"

         return postSyncronish(uriPath: path, params: params)
     }

     class func trigger(eventNamed event : String, withParameters params : [String:Any]) -> [String:Any] {
         let parsedEvent = parseQualifiedName(name: event)
         let path = "/api/v1/namespaces/\(parsedEvent.namespace)/triggers/\(parsedEvent.name)?blocking=true"

         return postSyncronish(uriPath: path, params: params)
     }

     // handle the GCD dance to make the post async, but then obtain/return
     // the result from this function sync
     private class func postSyncronish(uriPath path: String, params : [String:Any]) -> [String:Any] {
         var response : [String:Any]!

         let queue = DispatchQueue.global()
         let invokeGroup = DispatchGroup()

         invokeGroup.enter()
         queue.async {
             post(uriPath: path, params: params, group: invokeGroup) { result in
                 response = result
             }
         }

         // On one hand, FOREVER seems like an awfully long time...
         // But on the other hand, I think we can rely on the system to kill this
         // if it exceeds a reasonable execution time.
         switch invokeGroup.wait(timeout: DispatchTime.distantFuture) {
         case DispatchTimeoutResult.success:
             break
         case DispatchTimeoutResult.timedOut:
             break
         }

         return response
     }

     /**
      * Initializes with host, port and authKey determined from environment variables
      * __OW_API_HOST and __OW_API_KEY, respectively.
      */
     private class func initializeCommunication() -> (httpType: String, host : String, port : Int16, authKey : String) {
         let env = ProcessInfo.processInfo.environment

         var edgeHost : String!
         if let edgeHostEnv : String = env["__OW_API_HOST"] {
             edgeHost = "\(edgeHostEnv)"
         } else {
             fatalError("__OW_API_HOST environment variable was not set.")
         }

         var protocolIndex = edgeHost.startIndex

         //default to https
         var httpType = "https://"
         var port : Int16 = 443

         // check if protocol is included in environment variable
         if edgeHost.hasPrefix("https://") {
             protocolIndex = edgeHost.index(edgeHost.startIndex, offsetBy: 8)
         } else if edgeHost.hasPrefix("http://") {
             protocolIndex = edgeHost.index(edgeHost.startIndex, offsetBy: 7)
             httpType = "http://"
             port = 80
         }

         let hostname = edgeHost.substring(from: protocolIndex)
         let hostComponents = hostname.components(separatedBy: ":")

         let host = hostComponents[0]

         if hostComponents.count == 2 {
             port = Int16(hostComponents[1])!
         }

         var authKey = "authKey"
         if let authKeyEnv : String = env["__OW_API_KEY"] {
             authKey = authKeyEnv
         }

         return (httpType, host, port, authKey)
     }

     // actually do the POST call to the specified OpenWhisk URI path
     private class func post(uriPath: String, params : [String:Any], group: DispatchGroup, callback : @escaping([String:Any]) -> Void) {
         let communicationDetails = initializeCommunication()

         let loginData: Data = communicationDetails.authKey.data(using: String.Encoding.utf8, allowLossyConversion: false)!
         let base64EncodedAuthKey  = loginData.base64EncodedString(options: NSData.Base64EncodingOptions(rawValue: 0))

         let headers = ["Content-Type" : "application/json",
                        "Authorization" : "Basic \(base64EncodedAuthKey)"]

         guard let encodedPath = uriPath.addingPercentEncoding(withAllowedCharacters: CharacterSet.urlQueryAllowed) else {
             callback(["error": "Error encoding uri path to make openwhisk REST call."])
             return
         }

         // TODO vary the schema based on the port?
         let requestOptions = [ClientRequest.Options.schema(communicationDetails.httpType),
                               ClientRequest.Options.method("post"),
                               ClientRequest.Options.hostname(communicationDetails.host),
                               ClientRequest.Options.port(communicationDetails.port),
                               ClientRequest.Options.path(encodedPath),
                               ClientRequest.Options.headers(headers),
                               ClientRequest.Options.disableSSLVerification]

         let request = HTTP.request(requestOptions) { response in

             // exit group after we are done
             defer {
                 group.leave()
             }

             if response != nil {
                 do {
                     // this is odd, but that's just how KituraNet has you get
                     // the response as NSData
                     var jsonData = Data()
                     try response!.readAllData(into: &jsonData)

                     switch WhiskJsonUtils.getJsonType(jsonData: jsonData) {
                     case .Dictionary:
                         if let resp = WhiskJsonUtils.jsonDataToDictionary(jsonData: jsonData) {
                             callback(resp)
                         } else {
                             callback(["error": "Could not parse a valid JSON response."])
                         }
                     case .Array:
                         if WhiskJsonUtils.jsonDataToArray(jsonData: jsonData) != nil {
                             callback(["error": "Response is an array, expecting dictionary."])
                         } else {
                             callback(["error": "Could not parse a valid JSON response."])
                         }
                     case .Undefined:
                         callback(["error": "Could not parse a valid JSON response."])
                     }

                 } catch {
                     callback(["error": "Could not parse a valid JSON response."])
                 }
             } else {
                 callback(["error": "Did not receive a response."])
             }
         }

         // turn params into JSON data
         if let jsonData = WhiskJsonUtils.dictionaryToJsonString(jsonDict: params) {
             request.write(from: jsonData)
             request.end()
         } else {
             callback(["error": "Could not parse parameters."])
             group.leave()
         }

     }

     /**
      * This function is currently unused but ready when we want to switch to using URLSession instead of KituraNet.
      */
     private class func postUrlSession(uriPath: String, params : [String:Any], group: DispatchGroup, callback : @escaping([String:Any]) -> Void) {
         let communicationDetails = initializeCommunication()

         guard let encodedPath = uriPath.addingPercentEncoding(withAllowedCharacters: CharacterSet.urlQueryAllowed) else {
             callback(["error": "Error encoding uri path to make openwhisk REST call."])
             return
         }

         let urlStr = "\(communicationDetails.httpType)\(communicationDetails.host):\(communicationDetails.port)\(encodedPath)"

         if let url = URL(string: urlStr) {
             var request = URLRequest(url: url)
             request.httpMethod = "POST"

             do {
                 request.addValue("application/json", forHTTPHeaderField: "Content-Type")
                 request.httpBody = try JSONSerialization.data(withJSONObject: params)

                 let loginData: Data = communicationDetails.authKey.data(using: String.Encoding.utf8, allowLossyConversion: false)!
                 let base64EncodedAuthKey  = loginData.base64EncodedString(options: NSData.Base64EncodingOptions(rawValue: 0))
                 request.addValue("Basic \(base64EncodedAuthKey)", forHTTPHeaderField: "Authorization")

                 let session = URLSession(configuration: URLSessionConfiguration.default)

                 let task = session.dataTask(with: request, completionHandler: {data, response, error -> Void in

                     // exit group after we are done
                     defer {
                         group.leave()
                     }

                     if let error = error {
                         callback(["error":error.localizedDescription])
                     } else {

                         if let data = data {
                             do {
                                 let respJson = try JSONSerialization.jsonObject(with: data)
                                 if respJson is [String:Any] {
                                     callback(respJson as! [String:Any])
                                 } else {
                                     callback(["error":" response from server is not a dictionary"])
                                 }
                             } catch {
                                 callback(["error":"Error creating json from response: \(error)"])
                             }
                         }
                     }
                 })

                 task.resume()
             } catch {
                 callback(["error":"Got error creating params body: \(error)"])
             }
         }
     }

     // separate an OpenWhisk qualified name (e.g. "/whisk.system/samples/date")
     // into namespace and name components
     private class func parseQualifiedName(name qualifiedName : String) -> (namespace : String, name : String) {
         let defaultNamespace = "_"
         let delimiter = "/"

         let segments :[String] = qualifiedName.components(separatedBy: delimiter)

         if segments.count > 2 {
             return (segments[1], Array(segments[2..<segments.count]).joined(separator: delimiter))
         } else {
             // allow both "/theName" and "theName"
             let name = qualifiedName.hasPrefix(delimiter) ? segments[1] : segments[0]
             return (defaultNamespace, name)
         }
     }
 }
	/*
	* Copyright 2015-2016 IBM Corporation
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	import Foundation
	import KituraNet
	import Dispatch

	class Whisk {
	class func invoke(actionNamed action : String, withParameters params : [String:Any], blocking: Bool = true) -> [String:Any] {
	let parsedAction = parseQualifiedName(name: action)
	let strBlocking = blocking ? "true" : "false"
	let path = "/api/v1/namespaces/\(parsedAction.namespace)/actions/\(parsedAction.name)?blocking=\(strBlocking)"

	return postSyncronish(uriPath: path, params: params)
	}

	class func trigger(eventNamed event : String, withParameters params : [String:Any]) -> [String:Any] {
	let parsedEvent = parseQualifiedName(name: event)
	let path = "/api/v1/namespaces/\(parsedEvent.namespace)/triggers/\(parsedEvent.name)?blocking=true"

	return postSyncronish(uriPath: path, params: params)
	}

	// handle the GCD dance to make the post async, but then obtain/return
	// the result from this function sync
	private class func postSyncronish(uriPath path: String, params : [String:Any]) -> [String:Any] {
	var response : [String:Any]!

	let queue = DispatchQueue.global()
	let invokeGroup = DispatchGroup()

	invokeGroup.enter()
	queue.async {
	post(uriPath: path, params: params, group: invokeGroup) { result in
	response = result
	}
	}

	// On one hand, FOREVER seems like an awfully long time...
	// But on the other hand, I think we can rely on the system to kill this
	// if it exceeds a reasonable execution time.
	switch invokeGroup.wait(timeout: DispatchTime.distantFuture) {
	case DispatchTimeoutResult.success:
	break
	case DispatchTimeoutResult.timedOut:
	break
	}

	return response
	}

	/**
	* Initializes with host, port and authKey determined from environment variables
	* __OW_API_HOST and __OW_API_KEY, respectively.
	*/
	private class func initializeCommunication() -> (httpType: String, host : String, port : Int16, authKey : String) {
	let env = ProcessInfo.processInfo.environment

	var edgeHost : String!
	if let edgeHostEnv : String = env["__OW_API_HOST"] {
	edgeHost = "\(edgeHostEnv)"
	} else {
	fatalError("__OW_API_HOST environment variable was not set.")
	}

	var protocolIndex = edgeHost.startIndex

	//default to https
	var httpType = "https://"
	var port : Int16 = 443

	// check if protocol is included in environment variable
	if edgeHost.hasPrefix("https://") {
	protocolIndex = edgeHost.index(edgeHost.startIndex, offsetBy: 8)
	} else if edgeHost.hasPrefix("http://") {
	protocolIndex = edgeHost.index(edgeHost.startIndex, offsetBy: 7)
	httpType = "http://"
	port = 80
	}

	let hostname = edgeHost.substring(from: protocolIndex)
	let hostComponents = hostname.components(separatedBy: ":")

	let host = hostComponents[0]

	if hostComponents.count == 2 {
	port = Int16(hostComponents[1])!
	}

	var authKey = "authKey"
	if let authKeyEnv : String = env["__OW_API_KEY"] {
	authKey = authKeyEnv
	}

	return (httpType, host, port, authKey)
	}

	// actually do the POST call to the specified OpenWhisk URI path
	private class func post(uriPath: String, params : [String:Any], group: DispatchGroup, callback : @escaping([String:Any]) -> Void) {
	let communicationDetails = initializeCommunication()

	let loginData: Data = communicationDetails.authKey.data(using: String.Encoding.utf8, allowLossyConversion: false)!
	let base64EncodedAuthKey = loginData.base64EncodedString(options: NSData.Base64EncodingOptions(rawValue: 0))

	let headers = ["Content-Type" : "application/json",
	"Authorization" : "Basic \(base64EncodedAuthKey)"]

	guard let encodedPath = uriPath.addingPercentEncoding(withAllowedCharacters: CharacterSet.urlQueryAllowed) else {
	callback(["error": "Error encoding uri path to make openwhisk REST call."])
	return
	}

	// TODO vary the schema based on the port?
	let requestOptions = [ClientRequest.Options.schema(communicationDetails.httpType),
	ClientRequest.Options.method("post"),
	ClientRequest.Options.hostname(communicationDetails.host),
	ClientRequest.Options.port(communicationDetails.port),
	ClientRequest.Options.path(encodedPath),
	ClientRequest.Options.headers(headers),
	ClientRequest.Options.disableSSLVerification]

	let request = HTTP.request(requestOptions) { response in

	// exit group after we are done
	defer {
	group.leave()
	}

	if response != nil {
	do {
	// this is odd, but that's just how KituraNet has you get
	// the response as NSData
	var jsonData = Data()
	try response!.readAllData(into: &jsonData)

	switch WhiskJsonUtils.getJsonType(jsonData: jsonData) {
	case .Dictionary:
	if let resp = WhiskJsonUtils.jsonDataToDictionary(jsonData: jsonData) {
	callback(resp)
	} else {
	callback(["error": "Could not parse a valid JSON response."])
	}
	case .Array:
	if WhiskJsonUtils.jsonDataToArray(jsonData: jsonData) != nil {
	callback(["error": "Response is an array, expecting dictionary."])
	} else {
	callback(["error": "Could not parse a valid JSON response."])
	}
	case .Undefined:
	callback(["error": "Could not parse a valid JSON response."])
	}

	} catch {
	callback(["error": "Could not parse a valid JSON response."])
	}
	} else {
	callback(["error": "Did not receive a response."])
	}
	}

	// turn params into JSON data
	if let jsonData = WhiskJsonUtils.dictionaryToJsonString(jsonDict: params) {
	request.write(from: jsonData)
	request.end()
	} else {
	callback(["error": "Could not parse parameters."])
	group.leave()
	}

	}

	/**
	* This function is currently unused but ready when we want to switch to using URLSession instead of KituraNet.
	*/
	private class func postUrlSession(uriPath: String, params : [String:Any], group: DispatchGroup, callback : @escaping([String:Any]) -> Void) {
	let communicationDetails = initializeCommunication()

	guard let encodedPath = uriPath.addingPercentEncoding(withAllowedCharacters: CharacterSet.urlQueryAllowed) else {
	callback(["error": "Error encoding uri path to make openwhisk REST call."])
	return
	}

	let urlStr = "\(communicationDetails.httpType)\(communicationDetails.host):\(communicationDetails.port)\(encodedPath)"

	if let url = URL(string: urlStr) {
	var request = URLRequest(url: url)
	request.httpMethod = "POST"

	do {
	request.addValue("application/json", forHTTPHeaderField: "Content-Type")
	request.httpBody = try JSONSerialization.data(withJSONObject: params)

	let loginData: Data = communicationDetails.authKey.data(using: String.Encoding.utf8, allowLossyConversion: false)!
	let base64EncodedAuthKey = loginData.base64EncodedString(options: NSData.Base64EncodingOptions(rawValue: 0))
	request.addValue("Basic \(base64EncodedAuthKey)", forHTTPHeaderField: "Authorization")

	let session = URLSession(configuration: URLSessionConfiguration.default)

	let task = session.dataTask(with: request, completionHandler: {data, response, error -> Void in

	// exit group after we are done
	defer {
	group.leave()
	}

	if let error = error {
	callback(["error":error.localizedDescription])
	} else {

	if let data = data {
	do {
	let respJson = try JSONSerialization.jsonObject(with: data)
	if respJson is [String:Any] {
	callback(respJson as! [String:Any])
	} else {
	callback(["error":" response from server is not a dictionary"])
	}
	} catch {
	callback(["error":"Error creating json from response: \(error)"])
	}
	}
	}
	})

	task.resume()
	} catch {
	callback(["error":"Got error creating params body: \(error)"])
	}
	}
	}

	// separate an OpenWhisk qualified name (e.g. "/whisk.system/samples/date")
	// into namespace and name components
	private class func parseQualifiedName(name qualifiedName : String) -> (namespace : String, name : String) {
	let defaultNamespace = "_"
	let delimiter = "/"

	let segments :[String] = qualifiedName.components(separatedBy: delimiter)

	if segments.count > 2 {
	return (segments[1], Array(segments[2..<segments.count]).joined(separator: delimiter))
	} else {
	// allow both "/theName" and "theName"
	let name = qualifiedName.hasPrefix(delimiter) ? segments[1] : segments[0]
	return (defaultNamespace, name)
	}
	}
	}