github.com/hyperledger/burrow@v0.34.5-0.20220512172541-77f09336001d/deploy/jobs/jobs_test_jobs.go (about) 1 package jobs 2 3 import ( 4 "fmt" 5 "strconv" 6 7 hex "github.com/tmthrgd/go-hex" 8 9 "github.com/hyperledger/burrow/deploy/def" 10 "github.com/hyperledger/burrow/deploy/util" 11 "github.com/hyperledger/burrow/execution/evm/abi" 12 "github.com/hyperledger/burrow/logging" 13 ) 14 15 func QueryContractJob(query *def.QueryContract, do *def.DeployArgs, script *def.Playbook, client *def.Client, logger *logging.Logger) (string, []*abi.Variable, error) { 16 var queryDataArray []interface{} 17 var err error 18 query.Function, queryDataArray, err = util.PreProcessInputData(query.Function, query.Data, do, script, client, false, logger) 19 if err != nil { 20 return "", nil, err 21 } 22 23 query.Source = FirstOf(query.Source, script.Account) 24 25 // Get the packed data from the ABI functions 26 var data string 27 var packedBytes []byte 28 if query.Bin != "" { 29 packedBytes, _, err = abi.EncodeFunctionCallFromFile(query.Bin, script.BinPath, query.Function, logger, queryDataArray...) 30 data = hex.EncodeToString(packedBytes) 31 } 32 if query.Bin == "" || err != nil { 33 packedBytes, _, err = abi.EncodeFunctionCallFromFile(query.Destination, script.BinPath, query.Function, logger, queryDataArray...) 34 data = hex.EncodeToString(packedBytes) 35 } 36 if err != nil { 37 return "", nil, fmt.Errorf("error in QueryContractJob with %v: %w", 38 query, err) 39 } 40 41 logger.InfoMsg("Query contract", 42 "destination", query.Destination, 43 "function", query.Function, 44 "data", fmt.Sprint(query.Data)) 45 // Call the client 46 txe, err := client.QueryContract(&def.QueryArg{ 47 Input: query.Source, 48 Address: query.Destination, 49 Data: data, 50 }, logger) 51 if err != nil { 52 return "", nil, err 53 } 54 55 // Formally process the return 56 if query.Bin != "" { 57 logger.TraceMsg("Decoding Raw Result", 58 "return", hex.EncodeUpperToString(txe.Result.Return), 59 "Abi", query.Bin) 60 query.Variables, err = abi.DecodeFunctionReturnFromFile(query.Bin, script.BinPath, query.Function, txe.Result.Return, logger) 61 } 62 if query.Bin == "" || err != nil { 63 logger.TraceMsg("Decoding Raw Result", 64 "return", hex.EncodeUpperToString(txe.Result.Return), 65 "Abi", query.Destination) 66 query.Variables, err = abi.DecodeFunctionReturnFromFile(query.Destination, script.BinPath, query.Function, txe.Result.Return, logger) 67 } 68 if err != nil { 69 return "", nil, err 70 } 71 72 logEvents(txe, client, logger) 73 74 result2 := util.GetReturnValue(query.Variables, logger) 75 // Finalize 76 if result2 != "" { 77 logger.InfoMsg("Return Value", "value", result2) 78 } else { 79 logger.InfoMsg("No return.") 80 } 81 return result2, query.Variables, nil 82 } 83 84 func QueryAccountJob(query *def.QueryAccount, client *def.Client, logger *logging.Logger) (string, error) { 85 // Perform Query 86 arg := fmt.Sprintf("%s:%s", query.Account, query.Field) 87 logger.InfoMsg("Query Account", "argument", arg) 88 89 result, err := util.AccountsInfo(query.Account, query.Field, client, logger) 90 if err != nil { 91 return "", err 92 } 93 94 // Result 95 if result != "" { 96 logger.InfoMsg("Return Value", "value", result) 97 } else { 98 logger.InfoMsg("No return.") 99 } 100 return result, nil 101 } 102 103 func QueryNameJob(query *def.QueryName, client *def.Client, logger *logging.Logger) (string, error) { 104 // Peform query 105 logger.InfoMsg("Querying", 106 "name", query.Name, 107 "field", query.Field) 108 result, err := util.NamesInfo(query.Name, query.Field, client, logger) 109 if err != nil { 110 return "", err 111 } 112 113 if result != "" { 114 logger.InfoMsg("Return Value", "result", result) 115 } else { 116 logger.InfoMsg("No return.") 117 } 118 return result, nil 119 } 120 121 func QueryValsJob(query *def.QueryVals, client *def.Client, logger *logging.Logger) (interface{}, error) { 122 logger.InfoMsg("Querying Vals", "query", query.Query) 123 result, err := util.ValidatorsInfo(query.Query, client, logger) 124 if err != nil { 125 return "", fmt.Errorf("error querying validators with jq-style query %s: %v", query.Query, err) 126 } 127 128 if result != nil { 129 logger.InfoMsg("Return Value", "result", result) 130 } else { 131 logger.InfoMsg("No return.") 132 } 133 return result, nil 134 } 135 136 func AssertJob(assertion *def.Assert, logger *logging.Logger) (string, error) { 137 // Switch on relation 138 logger.InfoMsg("Assertion", 139 "key", assertion.Key, 140 "relation", assertion.Relation, 141 "value", assertion.Value) 142 143 switch assertion.Relation { 144 case "==", "eq": 145 /*log.Debug("Compare", strings.Compare(assertion.Key, assertion.Value)) 146 log.Debug("UTF8?: ", utf8.ValidString(assertion.Key)) 147 log.Debug("UTF8?: ", utf8.ValidString(assertion.Value)) 148 log.Debug("UTF8?: ", utf8.RuneCountInString(assertion.Key)) 149 log.Debug("UTF8?: ", utf8.RuneCountInString(assertion.Value))*/ 150 if assertion.Key == assertion.Value { 151 return assertPass("==", assertion.Key, assertion.Value, logger) 152 } else { 153 return assertFail("==", assertion.Key, assertion.Value, logger) 154 } 155 case "!=", "ne": 156 if assertion.Key != assertion.Value { 157 return assertPass("!=", assertion.Key, assertion.Value, logger) 158 } else { 159 return assertFail("!=", assertion.Key, assertion.Value, logger) 160 } 161 case ">", "gt": 162 k, v, err := bulkConvert(assertion.Key, assertion.Value) 163 if err != nil { 164 return convFail() 165 } 166 if k > v { 167 return assertPass(">", assertion.Key, assertion.Value, logger) 168 } else { 169 return assertFail(">", assertion.Key, assertion.Value, logger) 170 } 171 case ">=", "ge": 172 k, v, err := bulkConvert(assertion.Key, assertion.Value) 173 if err != nil { 174 return convFail() 175 } 176 if k >= v { 177 return assertPass(">=", assertion.Key, assertion.Value, logger) 178 } else { 179 return assertFail(">=", assertion.Key, assertion.Value, logger) 180 } 181 case "<", "lt": 182 k, v, err := bulkConvert(assertion.Key, assertion.Value) 183 if err != nil { 184 return convFail() 185 } 186 if k < v { 187 return assertPass("<", assertion.Key, assertion.Value, logger) 188 } else { 189 return assertFail("<", assertion.Key, assertion.Value, logger) 190 } 191 case "<=", "le": 192 k, v, err := bulkConvert(assertion.Key, assertion.Value) 193 if err != nil { 194 return convFail() 195 } 196 if k <= v { 197 return assertPass("<=", assertion.Key, assertion.Value, logger) 198 } else { 199 return assertFail("<=", assertion.Key, assertion.Value, logger) 200 } 201 default: 202 return "", fmt.Errorf("Error: Bad assert relation: \"%s\" is not a valid relation. See documentation for more information.", assertion.Relation) 203 } 204 } 205 206 func bulkConvert(key, value string) (int, int, error) { 207 k, err := strconv.Atoi(key) 208 if err != nil { 209 return 0, 0, err 210 } 211 v, err := strconv.Atoi(value) 212 if err != nil { 213 return 0, 0, err 214 } 215 return k, v, nil 216 } 217 218 func assertPass(typ, key, val string, logger *logging.Logger) (string, error) { 219 logger.InfoMsg("Assertion Succeeded", 220 "operation", typ, 221 "key", key, 222 "value", val) 223 return "passed", nil 224 } 225 226 func assertFail(typ, key, val string, logger *logging.Logger) (string, error) { 227 logger.InfoMsg("Assertion Failed", 228 "operation", typ, 229 "key", key, 230 "value", val) 231 return "failed", fmt.Errorf("assertion failed") 232 } 233 234 func convFail() (string, error) { 235 return "", fmt.Errorf("The Key of your assertion cannot be converted into an integer.\nFor string conversions please use the equal or not equal relations.") 236 }