test

   1 ////
   2 import groovy.json.JsonSlurper
   3 import groovy.transform.Field
   4
   5 class Logger {
   6     private boolean printToConsole = true
   7
   8     def methodMissing(String name, args) {
   9         def messsage = args[0]
  10         if (printToConsole) {
  11             println messsage
  12         }
  13     }
  14 }
  15
  16 ///////////////////////////////////////////////////
  17 class RequestBuckets {
  18         def jsonSlurper = new JsonSlurper()
  19         def JSON = jsonSlurper.parseText '''
  20                 {
  21                         "version": 1.06,
  22                         "accessKey": 100,
  23                         "bucketKey": 50,
  24                         "bucketName": "TEST",
  25                         "isBucketCreated": true,
  26                         "grokerSubdomain": "DOMAIN"
  27                 }'''
  28 }
  29 ///////////////////////////////////////////////////
  30
  31
  32 ///////////////////////////////////////////////////
  33 class Atomic {
  34         def version
  35         def accessKey
  36         def bucketKey
  37         def bucketName
  38         def isBucketCreated
  39         def grokerSubdomain
  40 }
  41 ///////////////////////////////////////////////////
  42
  43 @Field def log = new Logger()
  44 ///////////////////////////////////////////////////
  45 @Field def atomicState = new Atomic()
  46 @Field def request = new RequestBuckets()
  47 ///////////////////////////////////////////////////
  48
  49
  50 getAccessKey()
  51 getBucketKey()
  52 setBucketKey()
  53 setAccessKey()
  54 tryCreateBucket()
  55
  56 ///////////////////////////////////////////////////
  57 def httpError(int errorNumber, String errorReport) {
  58         println("---Just IGNORE---For http connection in a streamer app")
  59 }
  60 def httpPostJson(LinkedHashMap metaData, Closure Input) {
  61         Input(metaData)
  62 }
  63 ///////////////////////////////////////////////////
  64
  65
  66
  67 def getAccessKey() {
  68         log.trace "get access key"
  69         if (atomicState.accessKey == null) {
  70                 httpError(404, "Access Key Not Found")
  71         } else {
  72                 [
  73                         accessKey: atomicState.accessKey
  74                 ]
  75         }
  76 }
  77
  78 def getBucketKey() {
  79         log.trace "get bucket key"
  80         if (atomicState.bucketKey == null) {
  81                 httpError(404, "Bucket key Not Found")
  82         } else {
  83                 [
  84                         bucketKey: atomicState.bucketKey,
  85                         bucketName: atomicState.bucketName
  86                 ]
  87         }
  88 }
  89
  90 def setBucketKey() {
  91         log.trace "set bucket key"
  92         def newBucketKey = request.JSON?.bucketKey
  93         def newBucketName = request.JSON?.bucketName
  94
  95         log.debug "bucket name: $newBucketName"
  96         log.debug "bucket key: $newBucketKey"
  97
  98         if (newBucketKey && (newBucketKey != atomicState.bucketKey || newBucketName != atomicState.bucketName)) {
  99                 atomicState.bucketKey = "$newBucketKey"
 100                 atomicState.bucketName = "$newBucketName"
 101                 atomicState.isBucketCreated = false
 102         }
 103
 104         tryCreateBucket()
 105 }
 106
 107 def setAccessKey() {
 108         log.trace "set access key"
 109         def newAccessKey = request.JSON?.accessKey
 110         def newGrokerSubdomain = request.JSON?.grokerSubdomain
 111
 112         if (newGrokerSubdomain && newGrokerSubdomain != "" && newGrokerSubdomain != atomicState.grokerSubdomain) {
 113                 atomicState.grokerSubdomain = "$newGrokerSubdomain"
 114                 atomicState.isBucketCreated = false
 115         }
 116
 117         if (newAccessKey && newAccessKey != atomicState.accessKey) {
 118                 atomicState.accessKey = "$newAccessKey"
 119                 atomicState.isBucketCreated = false
 120         }
 121 }
 122
 123
 124
 125 def tryCreateBucket() {
 126
 127         // can't ship events if there is no grokerSubdomain
 128         if (atomicState.grokerSubdomain == null || atomicState.grokerSubdomain == "") {
 129                 log.error "streaming url is currently null"
 130                 return
 131         }
 132
 133         // if the bucket has already been created, no need to continue
 134         if (atomicState.isBucketCreated) {
 135                 return
 136         }
 137
 138         if (!atomicState.bucketName) {
 139         atomicState.bucketName = atomicState.bucketKey
 140     }
 141     if (!atomicState.accessKey) {
 142         return
 143     }
 144         def bucketName = "${atomicState.bucketName}"
 145         def bucketKey = "${atomicState.bucketKey}"
 146         def accessKey = "${atomicState.accessKey}"
 147
 148         def bucketCreateBody = new JsonSlurper().parseText("{\"bucketKey\": \"$bucketKey\", \"bucketName\": \"$bucketName\"}")
 149
 150         def bucketCreatePost = [
 151                 uri: "https://${atomicState.grokerSubdomain}.initialstate.com/api/buckets",
 152                 headers: [
 153                         "Content-Type": "application/json",
 154                         "X-IS-AccessKey": accessKey
 155                 ],
 156                 body: bucketCreateBody
 157         ]
 158
 159         log.debug bucketCreatePost
 160
 161         try {
 162                 // Create a bucket on Initial State so the data has a logical grouping
 163                 httpPostJson(bucketCreatePost) { resp ->
 164                         log.debug "bucket posted"
 165                         if (resp.status >= 400) {
 166                                 log.error "bucket not created successfully"
 167                         } else {
 168                                 atomicState.isBucketCreated = true
 169                         }
 170                 }
 171         } catch (e) {
 172                 log.error "bucket creation error: $e"
 173         }
 174
 175 }
 176
 177