github.com/braveheart12/just@v0.8.7/core/message/message.go (about) 1 /* 2 * Copyright 2019 Insolar Technologies 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 // Package message represents message that messagebus can route 18 package message 19 20 import ( 21 "bytes" 22 "encoding/gob" 23 "io" 24 "io/ioutil" 25 26 "github.com/ugorji/go/codec" 27 28 "github.com/pkg/errors" 29 30 "github.com/insolar/insolar/core" 31 ) 32 33 // GetEmptyMessage constructs specified message 34 func getEmptyMessage(mt core.MessageType) (core.Message, error) { 35 switch mt { 36 37 // Logicrunner 38 case core.TypeCallMethod: 39 return &CallMethod{}, nil 40 case core.TypeCallConstructor: 41 return &CallConstructor{}, nil 42 case core.TypeReturnResults: 43 return &ReturnResults{}, nil 44 case core.TypeExecutorResults: 45 return &ExecutorResults{}, nil 46 case core.TypeValidateCaseBind: 47 return &ValidateCaseBind{}, nil 48 case core.TypeValidationResults: 49 return &ValidationResults{}, nil 50 case core.TypePendingFinished: 51 return &PendingFinished{}, nil 52 case core.TypeStillExecuting: 53 return &StillExecuting{}, nil 54 55 // Ledger 56 case core.TypeGetCode: 57 return &GetCode{}, nil 58 case core.TypeGetObject: 59 return &GetObject{}, nil 60 case core.TypeGetDelegate: 61 return &GetDelegate{}, nil 62 case core.TypeGetChildren: 63 return &GetChildren{}, nil 64 case core.TypeUpdateObject: 65 return &UpdateObject{}, nil 66 case core.TypeRegisterChild: 67 return &RegisterChild{}, nil 68 case core.TypeJetDrop: 69 return &JetDrop{}, nil 70 case core.TypeSetRecord: 71 return &SetRecord{}, nil 72 case core.TypeGetObjectIndex: 73 return &GetObjectIndex{}, nil 74 case core.TypeValidationCheck: 75 return &ValidationCheck{}, nil 76 case core.TypeGetPendingRequests: 77 return &GetPendingRequests{}, nil 78 case core.TypeGetJet: 79 return &GetJet{}, nil 80 case core.TypeAbandonedRequestsNotification: 81 return &AbandonedRequestsNotification{}, nil 82 case core.TypeGetPendingRequestID: 83 return &GetPendingRequestID{}, nil 84 case core.TypeGetRequest: 85 return &GetRequest{}, nil 86 87 // heavy sync 88 case core.TypeHeavyStartStop: 89 return &HeavyStartStop{}, nil 90 case core.TypeHeavyPayload: 91 return &HeavyPayload{}, nil 92 case core.TypeHeavyReset: 93 return &HeavyReset{}, nil 94 // Bootstrap 95 case core.TypeBootstrapRequest: 96 return &GenesisRequest{}, nil 97 98 // NodeCert 99 case core.TypeNodeSignRequest: 100 return &NodeSignPayload{}, nil 101 default: 102 return nil, errors.Errorf("unimplemented message type %d", mt) 103 } 104 } 105 106 // MustSerializeBytes returns encoded core.Message, panics on error. 107 func MustSerializeBytes(msg core.Message) []byte { 108 r, err := Serialize(msg) 109 if err != nil { 110 panic(err) 111 } 112 b, err := ioutil.ReadAll(r) 113 if err != nil { 114 panic(err) 115 } 116 return b 117 } 118 119 // Serialize returns io.Reader on buffer with encoded core.Message. 120 func Serialize(msg core.Message) (io.Reader, error) { 121 buff := &bytes.Buffer{} 122 _, err := buff.Write([]byte{byte(msg.Type())}) 123 if err != nil { 124 return nil, err 125 } 126 127 enc := codec.NewEncoder(buff, &codec.CborHandle{}) 128 enc.MustEncode(msg) 129 return buff, err 130 } 131 132 // Deserialize returns decoded message. 133 func Deserialize(buff io.Reader) (core.Message, error) { 134 b := make([]byte, 1) 135 _, err := buff.Read(b) 136 if err != nil { 137 return nil, errors.New("too short slice for deserialize message") 138 } 139 140 msg, err := getEmptyMessage(core.MessageType(b[0])) 141 if err != nil { 142 return nil, err 143 } 144 enc := codec.NewDecoder(buff, &codec.CborHandle{}) 145 if err = enc.Decode(msg); err != nil { 146 return nil, err 147 } 148 return msg, nil 149 } 150 151 // ToBytes serialize a core.Message to bytes. 152 func ToBytes(msg core.Message) []byte { 153 reqBuff, err := Serialize(msg) 154 if err != nil { 155 panic(errors.Wrap(err, "failed to serialize message")) 156 } 157 buff, err := ioutil.ReadAll(reqBuff) 158 if err != nil { 159 panic(errors.Wrap(err, "failed to serialize message")) 160 } 161 return buff 162 } 163 164 // SerializeParcel returns io.Reader on buffer with encoded core.Parcel. 165 func SerializeParcel(parcel core.Parcel) (io.Reader, error) { 166 buff := &bytes.Buffer{} 167 enc := gob.NewEncoder(buff) 168 err := enc.Encode(parcel) 169 return buff, err 170 } 171 172 // DeserializeParcel returns decoded signed message. 173 func DeserializeParcel(buff io.Reader) (core.Parcel, error) { 174 var signed Parcel 175 enc := gob.NewDecoder(buff) 176 err := enc.Decode(&signed) 177 return &signed, err 178 } 179 180 // ParcelToBytes deserialize a core.Parcel to bytes. 181 func ParcelToBytes(msg core.Parcel) []byte { 182 reqBuff, err := SerializeParcel(msg) 183 if err != nil { 184 panic("failed to serialize message: " + err.Error()) 185 } 186 buf, err := ioutil.ReadAll(reqBuff) 187 if err != nil { 188 panic("failed to serialize message: " + err.Error()) 189 } 190 return buf 191 } 192 193 func init() { 194 // Bootstrap 195 gob.Register(&NodeSignPayload{}) 196 197 // Logicrunner 198 gob.Register(&CallConstructor{}) 199 gob.Register(&CallMethod{}) 200 gob.Register(&ReturnResults{}) 201 gob.Register(&ExecutorResults{}) 202 gob.Register(&ValidateCaseBind{}) 203 gob.Register(&ValidationResults{}) 204 gob.Register(&PendingFinished{}) 205 gob.Register(&StillExecuting{}) 206 207 // Ledger 208 gob.Register(&GetCode{}) 209 gob.Register(&GetObject{}) 210 gob.Register(&GetDelegate{}) 211 gob.Register(&UpdateObject{}) 212 gob.Register(&RegisterChild{}) 213 gob.Register(&JetDrop{}) 214 gob.Register(&SetRecord{}) 215 gob.Register(&GetObjectIndex{}) 216 gob.Register(&SetBlob{}) 217 gob.Register(&ValidateRecord{}) 218 gob.Register(&ValidationCheck{}) 219 gob.Register(&GetPendingRequests{}) 220 gob.Register(&GetJet{}) 221 gob.Register(&AbandonedRequestsNotification{}) 222 gob.Register(&HotData{}) 223 gob.Register(&GetPendingRequestID{}) 224 gob.Register(&GetRequest{}) 225 226 // heavy 227 gob.Register(&HeavyStartStop{}) 228 gob.Register(&HeavyPayload{}) 229 gob.Register(&HeavyReset{}) 230 231 // Bootstrap 232 gob.Register(&GenesisRequest{}) 233 gob.Register(&Parcel{}) 234 gob.Register(core.RecordRef{}) 235 gob.Register(&GetChildren{}) 236 237 // NodeCert 238 gob.Register(&NodeSignPayload{}) 239 }