impossiblefxv1 1.13.2

package/lib/http.js

@@ -0,0 +1,57 @@
+var FX = require('./core');
+
+FX.HttpRequest = FX.util.inherit({
+    constructor: function HttpRequest(service, operation) {
+        this.service = service
+        this.operation = operation
+
+        // TODO: change to ssl or httpProtocol to avoid conflict with "protocol"
+        this.protocol = service.config.protocol
+        this.data = null
+        this.auth = undefined
+        this.headers = {}
+
+        if(!FX.util.isBrowser) {
+          this.headers["x-fx-apiversion"] = service.apiVersion
+        }
+
+        this.hostname = service.config.endpoint
+        this.path = operation.http.path
+        this.method = operation.http.method
+        this.port = service.config.protocol == "https" ? 443 : 80
+    },
+
+    authenticate: function(callback) {
+      var self = this;
+      if(self.service.config.requiresAuth) {
+
+        self.service.config.getCredentials(function(err, creds){
+            if(err){
+              callback(err)
+            } else {
+              if(creds.apikey && creds.apisecret) {
+                self.auth = creds.apikey + ':' + creds.apisecret
+                callback(null)
+              } else if(creds.apitoken) {
+                self.headers["Authorization"] = "Bearer " + creds.apitoken
+                callback(null)
+              } else {
+                callback(new Error("No valid credentials found"))
+              }
+            }            
+        })
+      } else {
+        callback(null)
+      }
+    }
+
+});
+
+FX.HttpClient = FX.util.inherit({});
+
+FX.HttpClient.getInstance = function getInstance() {
+  if (this.singleton === undefined) {
+    this.singleton = new this();
+  }
+  return this.singleton;
+};

package/lib/proto.js

@@ -0,0 +1,38 @@
+var FX = require('./core')
+var ProtoBuf = require("protobufjs");
+
+var getProtoURL = function() {
+    var url = "";
+    if(!FX.util.isBrowser()) {
+        var path = require('path')
+        url = path.join(__dirname, '..', 'proto', 'fx.proto');
+    } else {
+        //url = "https://console.impossible.io/proto/fx.proto"
+
+        if (FX.config.protoURLPrefix){
+            url = FX.config.protoURLPrefix + "/fx.proto";
+        }else{
+            url = "https://is-console.s3.amazonaws.com/proto/fx.proto";
+        }
+    }
+
+    return url;
+}
+
+
+FX.SDL = FX.util.inherit({
+
+    constructor: function(options) {
+        var config = FX.util.copy(FX.config.SDL)
+        config.url = getProtoURL()
+        FX.util.update(config, options || {})
+
+        ProtoBuf.populateDefaults = config.populateDefaults;
+        console.log("Protobuf url is", config.url)
+
+        var builder = ProtoBuf.loadProtoFile(config.url)
+
+        return builder.build(config.domain);
+    },
+
+});

package/lib/protocol.js

@@ -0,0 +1,56 @@
+var FX = require('./core')
+
+var inherit = FX.util.inherit
+
+FX.Protocol = {
+
+    jsonbody: {
+        build: function(request, name, value, description) {
+            body = request.data || {}
+            value = value   || description.locationValue
+
+            if(typeof value ==  'object') {
+                value = JSON.parse(JSON.stringify(value))
+            }
+            var dest = body
+            var parts = description.locationName.split('.')
+            if(parts.length > 1) {
+                for(var p=0; p < parts.length - 1; p++) {
+                    dest[parts[p]] = dest[parts[p]] || {}
+                    dest = dest[parts[p]]
+                }
+                dest[parts[parts.length - 1]] = value
+            } else {
+                dest[parts[0]] = value
+            }
+
+            request.data = body
+        }
+    },
+
+    body: {
+        build: function(request, name, value, description) {
+            request.data = value
+        }
+    },
+
+    uri: {
+        build: function(request, name, value, description) {
+            var regex = new RegExp('\{' + description.locationName + '\}', 'g')
+            request.path = request.path.replace(regex, value);
+        }
+    },
+
+    json: {
+        build: function(params, members) {
+            var result = {}
+            FX.util.arrayEach(members, function(m){
+                result[m] = params[m]
+            })
+            return result
+        }
+    }
+
+
+
+}

package/lib/request.js

@@ -0,0 +1,252 @@
+var FX = require('./core')
+var inherit = FX.util.inherit
+
+FX.Request = inherit({
+
+    constructor: function Request(service, method, operation, params) {
+        this.startTime = FX.util.date.getDate();
+
+        this.service = service;
+        this.operation = operation;
+        this.method = method;
+        this.data = null;
+        this.params = {};
+        this.eventhandlers = {};
+        
+        FX.util.update(this.params, service.config.params || {})
+        FX.util.update(this.params, params || {})
+
+        this.httpRequest = this.buildHttpRequest()        
+        this.response = new FX.Response(this);
+        this.retryCount =  0;
+        this.startTime = new Date();
+    },
+
+    buildHttpRequest: function() {
+        var self = this;
+        var request = new FX.HttpRequest(self.service, self.operation)
+
+        if(this.operation.input) {
+            var inputtype = this.operation.input.type
+            if(inputtype== "structure") {
+                var inputparams = this.operation.input.members || {}
+                FX.util.each(inputparams, function(name, description) {
+
+//                    var translatedName = FX.util.string.lowerFirst(name)
+                    var translatedName = name
+                    var value = self.params[translatedName]
+
+                    // encode parameter
+                    if(description.encoding) {
+                        value = FX.Encoding[description.encoding].encode(value)
+                    }
+
+                    // build body, fill uri and querystring parameters
+                    if(FX.Protocol.hasOwnProperty(description.location)) {
+                        FX.Protocol[description.location].build(request, name, value, description)
+                    } else {
+                        //console.log("Request Builder: no protocol for", name)
+                    }
+                })   
+            }
+
+            if(this.operation.input.encoding) {
+                request.data = FX.Encoding[this.operation.input.encoding].encode(request.data)
+            }
+        }
+        return request
+    },
+
+    handleResponse: function(callback, body) {
+        var self = this;
+
+        if(self.response.error) {
+
+            if(body) {
+                errorMessage = body.toString()
+                try {
+                    self.response.error.message = JSON.parse(errorMessage)
+                } catch(error) {
+                    self.response.error.message = errorMessage
+                }
+            }
+
+            if(callback) {
+                callback(self.response.error, null)
+            }
+            
+            self.invokeHandlers('error', self.response)
+            
+
+        } else {
+
+            // transform response, usually a JSON transform
+            var protocol = self.service.api.metadata.protocol
+            if(self.operation.output && self.operation.output.protocol)
+                protocol = self.operation.output.protocol
+
+            if(protocol && body)
+                self.response.data = FX.Encoding[protocol].decode(body)
+
+            // operation specific response transformation
+            if(self.operation.transform) {
+                if(self.operation.transform.output) {
+                    self.service[self.operation.transform.output.method](self)    
+                }
+            }
+            
+            if(callback) {
+                callback(self.response.error, self.response.data)
+            } else {
+                self.invokeHandlers('success', self.response)
+            }
+        }
+
+
+        var logger = self.service.config.logger;
+        if(logger) {
+            var line = this.buildMessage(logger.isTTY);
+            if(typeof logger.log === 'function') {
+                logger.log(line);
+            } else if(typeof logger.write === 'function') {
+                logger.write(line + '\n');
+            }
+        }
+
+        self.invokeHandlers('complete', self.response)
+
+    },
+
+    send: function send(callback) {
+        var self = this;
+        FX.HttpClient.getInstance().exec(self.httpRequest, function(err, stream) {
+            self.response.stream = stream;
+
+            if(err) {
+                self.response.error = {
+                    code: 999,
+                    message: err
+                }
+                self.handleResponse(callback)
+                return
+            }
+
+            stream.on('aborted', function (err) {
+                self.response.error = {
+                    code: 999,
+                    message: err
+                }
+                self.handleResponse(callback)
+            })
+
+            stream.on('error', function (err) {
+                self.response.stream.abort()
+                
+                self.response.error = {
+                    code: 555,
+                    message: err
+                }
+                self.handleResponse(callback)
+            })
+
+
+            stream.on('response', function (response) {
+                if(response.setTimeout)
+                    response.setTimeout(self.service.config.responseTimeout || 600000)
+
+                self.response.httpResponse = response
+
+                if(response.statusCode >= 500) {
+                    if(self.retryCount < (self.service.config.maxRetries||10) ){
+                        self.retryCount++;
+                        var base = self.service.config.retryDelayBase || 100;
+                        var delay = Math.random() * (Math.pow(2, self.retryCount) * base);
+                        setTimeout(self.send.bind(self, callback), delay)
+                        return
+                    }
+                }
+
+                if(response.statusCode >= 400) {
+                    self.response.error = {
+                        code: response.statusCode
+                    }
+                }
+
+                if(!self.operation.output.payload) {
+                    var data = [];
+                    response.on('data', function (chunk) {
+                        data.push(chunk)
+                    });
+
+                    response.on('end', function () {
+                        var buffer = Buffer.concat(data)
+                        self.handleResponse(callback, buffer)
+                    });
+
+                } else {
+                    //Streamable response?
+                    self.handleResponse(callback)
+                }
+
+            });
+        })
+
+        return self;
+    },
+
+    promise: function() {
+        var self = this;
+        var PromiseDependency = self.service.config.promiseDependency || Promise
+
+        if(typeof PromiseDependency !== 'function') {
+            throw new Error("No PromiseDependency defined")
+        }
+
+        return new PromiseDependency(function(resolve, reject) {
+            self.on('success', function(response) {
+                resolve(response.data);
+            });
+            self.on('error', function(response) {
+                reject(response.error);
+            });
+            
+            self.send();
+      });        
+    },
+
+    on: function(event, callback) {
+        var handlers = this.eventhandlers[event] || []
+        handlers.push(callback)
+        this.eventhandlers[event] = handlers
+        return this;
+    },
+
+    invokeHandlers: function(event) {
+        var args = Array.prototype.slice.call(arguments, 1);
+        var handlers = this.eventhandlers[event] || []
+        FX.util.arrayEach(handlers, function(handler){
+            handler.apply(null, args)
+        })
+    },
+
+    buildMessage: function(ansi) {
+        var time = new Date();
+        var delta = (time - this.startTime) / 1000;
+        var status = this.response.httpResponse.statusCode;
+        var params = JSON.stringify(this.params)
+
+        var message = '';
+        if (ansi) message += '\x1B[34m';
+        message += '[FX ' + this.service.identifier + ' ' + status;
+        message += ' ' + delta.toString() + 's ' + this.retryCount + ' retries]';
+        if (ansi) message += '\x1B[0;1m';
+        message += ' ' + FX.util.string.lowerFirst(this.method);
+        message += '(' + params + ')';
+        if (ansi) message += '\x1B[0m';
+        return message;
+      }
+
+})
+
+
+

package/lib/response.js

@@ -0,0 +1,24 @@
+var FX = require('./core')
+var inherit = FX.util.inherit
+
+FX.Response = inherit({
+    constructor: function Response(request) {
+        this.request = request;
+        this.data = null;
+        this.error = null;
+        this.stream = null
+        this.httpResponse = null;
+        
+        this.retryCount = 0;
+        this.redirectCount = 0;
+        // if (request) {
+        //     this.maxRetries = request.service.numRetries();
+        //     this.maxRedirects = request.service.config.maxRedirects;
+        // }
+    },
+
+
+})
+
+
+

package/lib/service.js

@@ -0,0 +1,182 @@
+var FX = require('./core');
+var configureEndpoint = require('./endpoint');
+
+//var Api = require('./model/api');
+var path = require('path');
+var inherit = FX.util.inherit;
+var apiRoot = path.join(__dirname, '..', 'apis');
+
+FX.Service = inherit({
+
+    constructor: function Service(config) {
+
+        if(!this.loadServiceClass) {
+            throw Error('Service must be constructed with `new\' operator');
+        }
+
+        var ServiceClass = this.loadServiceClass(config || {});
+
+        if (ServiceClass) {
+            var svc = new ServiceClass(config);
+            return svc;
+        }
+
+        this.initialize(config);
+    },
+
+    initialize: function(config) {
+        var svcConfig = FX.config[this.identifier];
+
+        this.config = new FX.Config(FX.config);
+  
+        if (svcConfig) 
+            this.config.update(svcConfig, true);
+
+        if (config) {
+            this.config.update(config, true);        
+        } 
+
+        if (!this.config.endpoint) 
+            configureEndpoint(this);
+
+        if(!this.config.region && !this.api.globalEndpoint)
+            throw new Error("No region specified")
+    },
+
+    loadServiceClass: function(serviceConfig) {
+        var config = serviceConfig;
+
+        if (!FX.util.isEmpty(this.api)) {
+            return null;
+        } else if (config.apiConfig) {
+            return FX.Service.defineServiceApi(this.constructor, config.apiConfig);
+        } else if (!this.constructor.services) {
+            return null;
+        } else {
+            config = new FX.Config(FX.config);
+            config.update(serviceConfig, true);
+            var version = config.apiVersions[this.constructor.identifier]
+            version = FX.config.apiVersion || version 
+            version = config.apiVersion || version;
+            
+            return this.getLatestServiceClass(version);
+        }
+    },
+
+    getLatestServiceClass: function(version) {
+        version = this.getLatestServiceVersion(version);
+
+        // serviceApi does not exist for this version. create one
+        if(!this.constructor.services[version]) {
+            FX.Service.defineServiceApi(this.constructor, version);
+        }
+
+        return this.constructor.services[version];
+    },
+
+
+    getLatestServiceVersion: function(version) {
+        if (Object.hasOwnProperty(this.constructor.versions, version)) {
+            return version;
+        }
+    
+        var versions = this.constructor.versions
+        if(versions == undefined)
+            return
+
+        versions.sort();
+        for(var i = versions.length - 1; i >= 0; i--) {
+            if(versions[i] <= version) {
+                return versions[i];
+            }
+        }
+
+        throw new Error('Could not find a version for service')
+    },
+
+
+    makeRequest: function(method, params, callback) {
+        if(typeof params == 'function') {
+            callback = params
+            params = {}
+        }
+
+        var operation = this.api.operations[method]
+        var transform = operation.transform || {}
+
+        // Copy parameters bound to service
+        params = params || {};
+        if(this.config.params && operation.input) {
+            FX.util.each(this.config.params, function(key, value) {
+                if(operation.input.members && operation.input.members[key]) {
+                    if (params[key] === undefined || params[key] === null) {
+                        params[key] = value;
+                    }
+                }
+            });
+        } 
+
+        if(transform.input) {
+            this[transform.input.method]()    
+        }
+
+        var request = new FX.Request(this, method, operation, params)
+        if(callback) {
+            request.send(callback)
+        }
+
+        return request
+    }
+
+});
+
+
+FX.util.update(FX.Service, {
+
+    defineServiceApi: function(superclass, version) {
+        var svc = inherit(superclass, {
+            identifier: superclass.identifier,
+            apiVersion: version,
+            version: version
+        });
+
+        
+        var api =  FX.apiLoader(superclass.identifier, version);
+        svc.prototype.api = api;
+        superclass.services[version] = svc;
+
+        FX.Service.defineMethods(svc);
+        FX.config[superclass.identifier] = api.config || {}
+        
+        return svc;
+    },
+
+
+    serviceFile: function(svcname, version) {
+       return path.join(apiRoot, svcname + '-' + version + '.json')
+    },
+
+    defineMethods: function(svc) {
+        FX.util.each(svc.prototype.api.operations, function iterator(method) {
+            var jsMethodName = FX.util.string.lowerFirst(method)
+
+            svc.prototype[jsMethodName] = function (params, callback) {
+                return this.makeRequest(method, params, callback)
+            };            
+        })
+    },
+
+    defineService: function(name, versions) {
+        var svc = inherit(FX.Service, {})
+        svc.versions = versions
+        svc.services = {}
+        svc.identifier = name   
+
+        return svc 
+    },
+        // var util = require('util');
+        // console.log(util.inspect(svc, {showHidden: false, depth: null}));
+
+
+})
+

package/lib/services/batch.js

@@ -0,0 +1,5 @@
+
+var FX = require('../core');
+
+FX.util.update(FX.Batch.prototype, {
+})

package/lib/services/edit.js

@@ -0,0 +1,9 @@
+
+
+var FX = require('../core');
+
+FX.util.update(FX.Edit.prototype, {
+
+
+})
+