func CreateCredHandler(w http.ResponseWriter, r *http.Request) {
// TODO: Prevent making the same cred a second time
cred := &credence.Cred{}
if err := jsonpb.Unmarshal(r.Body, cred); err != nil {
w.WriteHeader(http.StatusBadRequest)
return
}
fingerprint := len(r.URL.Query()["fingerprint"]) > 0
confirm := len(r.URL.Query()["confirm"]) > 0
signingUser := models.Me()
if !confirm && helpers.StatementAlreadyMade(cred, signingUser) {
w.WriteHeader(http.StatusConflict)
return
}
if fingerprint {
cred.AuthorFingerprint = signingUser.Fingerprint
}
// Set attributes
cred.Timestamp = time.Now().Unix()
err := helpers.SetSignature(cred)
if err != nil {
panic(err)
}
// Store in the DB
helpers.StoreCredWithAuthor(cred, signingUser)
// Set up the broadcaster
broadcaster, err := goczmq.NewPush("inproc://broadcast")
if err != nil {
panic(err)
}
defer broadcaster.Destroy()
// Create the broadcastable bytes
msg := &credence.Message{
Type: &credence.Message_Cred{
Cred: cred,
},
}
msgBytes, err := proto.Marshal(msg)
if err != nil {
log.Print(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
_, err = broadcaster.Write(msgBytes)
if err != nil {
panic(err)
}
helpers.ModelNegotiator().Negotiate(w, r, cred)
}
// readBlock returns the block or nil, and whether the block was found or not, (nil,true) generally indicates an irrecoverable problem
func (fl *fileLedger) readBlock(number uint64) (*cb.Block, bool) {
file, err := os.Open(fl.blockFilename(number))
if err == nil {
defer file.Close()
block := &cb.Block{}
err = jsonpb.Unmarshal(file, block)
if err != nil {
return nil, true
}
logger.Debugf("Read block %d", block.Header.Number)
return block, true
}
return nil, false
}
func discoveryGet(clictx *cli.Context) error {
var err error
var opts []grpc.DialOption
if insecureDiscovery {
opts = append(opts, grpc.WithInsecure())
} else {
auth := credentials.NewClientTLSFromCert(nil, getServerName(discoveryServiceURL))
opts = append(opts, grpc.WithTransportCredentials(auth))
}
logrus.Infof("discovery.go: connecting to discovery service at url %s", discoveryServiceURL)
dcon, err := grpc.Dial(discoveryServiceURL, opts...)
if err != nil {
logrus.Fatalf("discovery.go: error while connection to discovery service %v", err)
}
dc := pb.NewDiscoveryClient(dcon)
ctx, _ := context.WithTimeout(context.Background(), 5*time.Second)
req := pb.DiscoveryRequest{}
if filename := clictx.String("filename"); filename != "" {
d, err := os.Open(filename)
if err != nil {
return err
}
defer d.Close()
if err := jsonpb.Unmarshal(d, &req); err != nil {
return err
}
} else {
req.Environment = clictx.String("env")
req.SdkVersion = clictx.String("sdk")
req.OsName = clictx.String("os")
req.CountryCode = clictx.String("country-code")
req.AppBundleId = clictx.String("bundle-id")
req.AppBundleVersion = clictx.String("bundle-version")
}
res, err := dc.Get(ctx, &req)
if err != nil {
return err
}
m := jsonpb.Marshaler{EnumsAsInts: false, EmitDefaults: true, Indent: " "}
s, err := m.MarshalToString(res)
fmt.Println(s)
return nil
}
func (s *Server) callGRPCMethod(id MethodID, data io.Reader) (*proto.Message, error) {
decode := func(v interface{}) error {
if err := jsonpb.Unmarshal(data, v.(proto.Message)); err != nil {
return fmt.Errorf("invalid method (%s) data", id)
}
return nil
}
h, ok := s.handlers[id]
if !ok {
return nil, fmt.Errorf("method handler not found - %s", id)
}
reply, err := h.md.Handler(h.srv, context.Background(), decode)
if err != nil {
return nil, err
}
replyMsg := reply.(proto.Message)
return &replyMsg, nil
}
func AddUserHandler(w http.ResponseWriter, r *http.Request) {
confirmAdd := len(r.URL.Query()["confirm"]) > 0
identityAssertion := &credence.IdentityAssertion{}
if err := jsonpb.Unmarshal(r.Body, identityAssertion); err != nil {
w.WriteHeader(http.StatusBadRequest)
return
}
if confirmAdd {
// TODO: Implement
w.WriteHeader(http.StatusNotImplemented)
return
} else {
// TODO: Proper CORS
w.Header().Set("Access-Control-Allow-Origin", "*")
io.WriteString(w, identityAssertion.String())
return
}
}
func LoadPackage(path string) (*PackageWrapper, error) {
var err error
pw := &PackageWrapper{Package: &msg.Package{}}
packageFile := filepath.Join(path, core.PackageFile)
if _, err = os.Stat(packageFile); err == nil {
var file *os.File
if file, err = os.Open(packageFile); err != nil {
return pw, err
}
defer file.Close()
if err = json.Unmarshal(file, pw.Package); err != nil {
return pw, err
}
pw.FilePath, err = filepath.Abs(file.Name())
}
return pw, err
}
// Controller for `/api/v1/track`
func TrackHandler(w http.ResponseWriter, r *http.Request) {
// Do not accept new events while the server is shutting down.
if isTerminating {
BroadcastError(w, "Server is currenly shutting down", http.StatusServiceUnavailable)
return
}
// Ignore not POST messages.
if r.Method != "POST" {
BroadcastError(w, "Sending method is not POST", http.StatusMethodNotAllowed)
return
}
// Checks that the client want to send signature or not
definedSignature := r.Header.Get("X-Hamustro-Time") != "" || r.Header.Get("X-Hamustro-Signature") != ""
// If the client did not send time, we ignore
if (signatureRequired || definedSignature) && r.Header.Get("X-Hamustro-Time") == "" {
BroadcastError(w, "X-Hamustro-Time header is missing", http.StatusMethodNotAllowed)
return
}
// If the client did not send signature of the message, we ignore
if (signatureRequired || definedSignature) && r.Header.Get("X-Hamustro-Signature") == "" {
BroadcastError(w, "X-Hamustro-Signature header is missing", http.StatusMethodNotAllowed)
return
}
// Read the requests body into a variable.
body, _ := ioutil.ReadAll(r.Body)
// Calculate the request's signature
if (signatureRequired || definedSignature) && r.Header.Get("X-Hamustro-Signature") != GetSignature(body, r.Header.Get("X-Hamustro-Time")) {
BroadcastError(w, "X-Hamustro-Signature header is invalid", http.StatusMethodNotAllowed)
return
}
collection := &payload.Collection{}
contentType, _, _ := mime.ParseMediaType(r.Header.Get("Content-Type"))
switch contentType {
case "application/json":
if err := jsonpb.Unmarshal(bytes.NewBuffer(body), collection); err != nil {
BroadcastError(w, fmt.Sprintf("Unmarshaling json collection is failed: %s", err.Error()), http.StatusBadRequest)
return
}
if !collection.IsValid() {
BroadcastError(w, fmt.Sprintf("Unmarshaled json collection is failed: required field not set"), http.StatusBadRequest)
return
}
case "application/protobuf":
if err := proto.Unmarshal(body, collection); err != nil {
BroadcastError(w, fmt.Sprintf("Unmarshaling protobuf is failed: %s", err.Error()), http.StatusBadRequest)
return
}
default:
BroadcastError(w, "Unsupported or missing Content-Type", http.StatusBadRequest)
return
}
// Checks the session information
if GetSession(collection) != collection.GetSession() {
BroadcastError(w, "Collection's session attribute is invalid", http.StatusBadRequest)
return
}
// Stop if no payload information was received
if !collection.HasPayloads() {
w.WriteHeader(http.StatusNoContent)
return
}
// Creates a Job and put into the JobQueue for processing.
for _, payload := range collection.GetPayloads() {
event := dialects.NewEvent(collection, payload)
if config.IsMaskedIP() {
event.TruncateIPv4LastOctet()
}
action := EventAction{event, 1}
jobQueue <- &action
}
// Returns with 200.
w.WriteHeader(http.StatusOK)
}
func (i *restAPIHandler) POSTListing(w http.ResponseWriter, r *http.Request) {
w.Header().Add("Content-Type", "application/json")
l := new(pb.Listing)
jsonpb.Unmarshal(r.Body, l)
listingPath := path.Join(i.node.RepoPath, "root", "listings", l.ListingName)
if err := os.MkdirAll(listingPath, os.ModePerm); err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, `{"success": false, "reason": "%s"}`, err)
return
}
contract, err := i.node.SignListing(l)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, `{"success": false, "reason": "%s"}`, err)
return
}
f, err := os.Create(path.Join(listingPath, "listing.json"))
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, `{"success": false, "reason": "%s"}`, err)
return
}
defer func() {
if err := f.Close(); err != nil {
panic(err)
}
}()
m := jsonpb.Marshaler{
EnumsAsInts: false,
EmitDefaults: false,
Indent: " ",
OrigName: false,
}
out, err := m.MarshalToString(contract)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(w, `{"success": false, "reason": "%s"}`, err)
return
}
if _, err := f.WriteString(out); err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, `{"success": false, "reason": "%s"}`, err)
return
}
err = i.node.UpdateListingIndex(contract)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, `{"success": false, "reason": "%s"}`, err)
return
}
if err := i.node.SeedNode(); err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, `{"success": false, "reason": "%s"}`, err)
return
}
fmt.Fprintf(w, `{"success": true}`)
}
func socketHandler(w http.ResponseWriter, r *http.Request) {
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Printf("Error upgrading to websocket: %q", err.Error())
return
}
// Listen for update requests over the websocket.
go func(c *websocket.Conn) {
for _, r, err := c.NextReader(); err == nil; _, r, err = c.NextReader() {
reqL.Lock()
if req == nil {
log.Printf("Not connected to REQ/REP on pub\n")
continue
}
reqL.Unlock()
msg := &cell.UpdateRequest{}
if err := jsonpb.Unmarshal(r, msg); err != nil {
log.Printf("Error unmarshalling UpdateRequest: %q\n", err.Error())
continue
}
data, err := proto.Marshal(msg)
if err != nil {
log.Fatal("Marshaling error: %q\n\tfor %#v\n", err.Error(), *msg)
}
reqL.Lock()
if err = req.SendMessage([][]byte{data}); err != nil {
log.Printf("Error sending request: %q\n", err.Error())
continue
}
if _, err = req.RecvMessage(); err != nil {
log.Printf("Error receiving reply: %q\n", err.Error())
continue
}
reqL.Unlock()
}
c.Close()
}(conn)
cond.L.Lock()
prev := curr - 1
cond.L.Unlock()
for {
cond.L.Lock()
for prev == curr {
cond.Wait()
}
prev = curr
cond.L.Unlock()
if err = conn.WriteJSON(struct {
SeqNum int
}{prev}); err != nil {
log.Printf("Error writing sequence number: %q", err.Error())
return
}
}
}
// Query performs the requested query on the target Chaincode.
func (s *ServerOpenchainREST) Query(rw web.ResponseWriter, req *web.Request) {
restLogger.Info("REST querying chaincode...")
// Decode the incoming JSON payload
var spec pb.ChaincodeInvocationSpec
err := jsonpb.Unmarshal(req.Body, &spec)
// Check for proper JSON syntax
if err != nil {
// Unmarshall returns a " character around unrecognized fields in the case
// of a schema validation failure. These must be replaced with a ' character.
// Otherwise, the returned JSON is invalid.
errVal := strings.Replace(err.Error(), "\"", "'", -1)
// Client must supply payload
if err == io.EOF {
rw.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(rw, "{\"Error\": \"Payload must contain a ChaincodeInvocationSpec.\"}")
restLogger.Error("{\"Error\": \"Payload must contain a ChaincodeInvocationSpec.\"}")
} else {
rw.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(rw, "{\"Error\": \"%s\"}", errVal)
restLogger.Error(fmt.Sprintf("{\"Error\": \"%s\"}", errVal))
}
return
}
// Check that the ChaincodeSpec is not left blank.
if spec.ChaincodeSpec == nil {
rw.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(rw, "{\"Error\": \"Payload must contain a ChaincodeSpec.\"}")
restLogger.Error("{\"Error\": \"Payload must contain a ChaincodeSpec.\"}")
return
}
// Check that the ChaincodeID is not left blank.
if spec.ChaincodeSpec.ChaincodeID == nil {
rw.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(rw, "{\"Error\": \"Payload must contain a ChaincodeID.\"}")
restLogger.Error("{\"Error\": \"Payload must contain a ChaincodeID.\"}")
return
}
// Check that the Chaincode name is not blank.
if spec.ChaincodeSpec.ChaincodeID.Name == "" {
rw.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(rw, "{\"Error\": \"Chaincode name may not be blank.\"}")
restLogger.Error("{\"Error\": \"Chaincode name may not be blank.\"}")
return
}
// Check that the CtorMsg is not left blank.
if (spec.ChaincodeSpec.CtorMsg == nil) || (spec.ChaincodeSpec.CtorMsg.Function == "") {
rw.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(rw, "{\"Error\": \"Payload must contain a CtorMsg with a Chaincode function name.\"}")
restLogger.Error("{\"Error\": \"Payload must contain a CtorMsg with a Chaincode function name.\"}")
return
}
// If security is enabled, add client login token
if viper.GetBool("security.enabled") {
chaincodeUsr := spec.ChaincodeSpec.SecureContext
if chaincodeUsr == "" {
rw.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(rw, "{\"Error\": \"Must supply username for chaincode when security is enabled.\"}")
restLogger.Error("{\"Error\": \"Must supply username for chaincode when security is enabled.\"}")
return
}
// Retrieve the REST data storage path
// Returns /var/openchain/production/client/
localStore := getRESTFilePath()
// Check if the user is logged in before sending transaction
if _, err := os.Stat(localStore + "loginToken_" + chaincodeUsr); err == nil {
restLogger.Info("Local user '%s' is already logged in. Retrieving login token.\n", chaincodeUsr)
// Read in the login token
token, err := ioutil.ReadFile(localStore + "loginToken_" + chaincodeUsr)
if err != nil {
rw.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(rw, "{\"Error\": \"Fatal error -- %s\"}", err)
panic(fmt.Errorf("Fatal error when reading client login token: %s\n", err))
}
// Add the login token to the chaincodeSpec
spec.ChaincodeSpec.SecureContext = string(token)
// If privacy is enabled, mark chaincode as confidential
if viper.GetBool("security.privacy") {
spec.ChaincodeSpec.ConfidentialityLevel = pb.ConfidentialityLevel_CONFIDENTIAL
}
} else {
// Check if the token is not there and fail
if os.IsNotExist(err) {
rw.WriteHeader(http.StatusUnauthorized)
fmt.Fprintf(rw, "{\"Error\": \"User not logged in. Use the '/registrar' endpoint to obtain a security token.\"}")
restLogger.Error("{\"Error\": \"User not logged in. Use the '/registrar' endpoint to obtain a security token.\"}")
return
}
// Unexpected error
rw.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(rw, "{\"Error\": \"Fatal error -- %s\"}", err)
panic(fmt.Errorf("Fatal error when checking for client login token: %s\n", err))
}
}
// Query the chainCode
resp, err := s.devops.Query(context.Background(), &spec)
if err != nil {
// Replace " characters with '
errVal := strings.Replace(err.Error(), "\"", "'", -1)
rw.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(rw, "{\"Error\": \"%s\"}", errVal)
restLogger.Error(fmt.Sprintf("{\"Error\": \"Querying Chaincode -- %s\"}", errVal))
return
}
// Determine if the response received is JSON formatted
if isJSON(string(resp.Msg)) {
// Response is JSON formatted, return it as is
rw.WriteHeader(http.StatusOK)
fmt.Fprintf(rw, "{\"OK\": %s}", string(resp.Msg))
} else {
// Response is not JSON formatted, construct a JSON formatted response
jsonResponse, err := json.Marshal(restResult{OK: string(resp.Msg)})
if err != nil {
rw.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(rw, "{\"Error\": \"%s\"}", err)
restLogger.Error(fmt.Sprintf("{\"Error marshalling query response\": \"%s\"}", err))
return
}
rw.WriteHeader(http.StatusOK)
fmt.Fprintf(rw, string(jsonResponse))
}
}
// Deploy first builds the chaincode package and subsequently deploys it to the
// blockchain.
func (s *ServerOpenchainREST) Deploy(rw web.ResponseWriter, req *web.Request) {
restLogger.Info("REST deploying chaincode...")
// Decode the incoming JSON payload
var spec pb.ChaincodeSpec
err := jsonpb.Unmarshal(req.Body, &spec)
// Check for proper JSON syntax
if err != nil {
// Unmarshall returns a " character around unrecognized fields in the case
// of a schema validation failure. These must be replaced with a ' character.
// Otherwise, the returned JSON is invalid.
errVal := strings.Replace(err.Error(), "\"", "'", -1)
// Client must supply payload
if err == io.EOF {
rw.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(rw, "{\"Error\": \"Payload must contain a ChaincodeSpec.\"}")
restLogger.Error("{\"Error\": \"Payload must contain a ChaincodeSpec.\"}")
} else {
rw.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(rw, "{\"Error\": \"%s\"}", errVal)
restLogger.Error(fmt.Sprintf("{\"Error\": \"%s\"}", errVal))
}
return
}
// Check that the ChaincodeID is not nil.
if spec.ChaincodeID == nil {
rw.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(rw, "{\"Error\": \"Payload must contain a ChaincodeID.\"}")
restLogger.Error("{\"Error\": \"Payload must contain a ChaincodeID.\"}")
return
}
// If the peer is running in development mode, confirm that the Chaincode name
// is not left blank. If the peer is running in production mode, confirm that
// the Chaincode path is not left blank. This is necessary as in development
// mode, the chaincode is identified by name not by path during the deploy
// process.
if viper.GetString("chaincode.mode") == chaincode.DevModeUserRunsChaincode {
// Check that the Chaincode name is not blank.
if spec.ChaincodeID.Name == "" {
rw.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(rw, "{\"Error\": \"Chaincode name may not be blank in development mode.\"}")
restLogger.Error("{\"Error\": \"Chaincode name may not be blank in development mode.\"}")
return
}
} else {
// Check that the Chaincode path is not left blank.
if spec.ChaincodeID.Path == "" {
rw.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(rw, "{\"Error\": \"Chaincode path may not be blank.\"}")
restLogger.Error("{\"Error\": \"Chaincode path may not be blank.\"}")
return
}
}
// If security is enabled, add client login token
if viper.GetBool("security.enabled") {
chaincodeUsr := spec.SecureContext
if chaincodeUsr == "" {
rw.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(rw, "{\"Error\": \"Must supply username for chaincode when security is enabled.\"}")
restLogger.Error("{\"Error\": \"Must supply username for chaincode when security is enabled.\"}")
return
}
// Retrieve the REST data storage path
// Returns /var/openchain/production/client/
localStore := getRESTFilePath()
// Check if the user is logged in before sending transaction
if _, err := os.Stat(localStore + "loginToken_" + chaincodeUsr); err == nil {
restLogger.Info("Local user '%s' is already logged in. Retrieving login token.\n", chaincodeUsr)
// Read in the login token
token, err := ioutil.ReadFile(localStore + "loginToken_" + chaincodeUsr)
if err != nil {
rw.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(rw, "{\"Error\": \"Fatal error -- %s\"}", err)
panic(fmt.Errorf("Fatal error when reading client login token: %s\n", err))
}
// Add the login token to the chaincodeSpec
spec.SecureContext = string(token)
// If privacy is enabled, mark chaincode as confidential
if viper.GetBool("security.privacy") {
spec.ConfidentialityLevel = pb.ConfidentialityLevel_CONFIDENTIAL
}
} else {
// Check if the token is not there and fail
if os.IsNotExist(err) {
rw.WriteHeader(http.StatusUnauthorized)
fmt.Fprintf(rw, "{\"Error\": \"User not logged in. Use the '/registrar' endpoint to obtain a security token.\"}")
restLogger.Error("{\"Error\": \"User not logged in. Use the '/registrar' endpoint to obtain a security token.\"}")
return
}
// Unexpected error
rw.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(rw, "{\"Error\": \"Fatal error -- %s\"}", err)
panic(fmt.Errorf("Fatal error when checking for client login token: %s\n", err))
}
}
// Deploy the ChaincodeSpec
chaincodeDeploymentSpec, err := s.devops.Deploy(context.Background(), &spec)
if err != nil {
// Replace " characters with '
errVal := strings.Replace(err.Error(), "\"", "'", -1)
rw.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(rw, "{\"Error\": \"%s\"}", errVal)
restLogger.Error(fmt.Sprintf("{\"Error\": \"Deploying Chaincode -- %s\"}", errVal))
return
}
// Clients will need the chaincode name in order to invoke or query it
chainID := chaincodeDeploymentSpec.ChaincodeSpec.ChaincodeID.Name
rw.WriteHeader(http.StatusOK)
fmt.Fprintf(rw, "{\"OK\": \"Successfully deployed chainCode.\",\"message\":\""+chainID+"\"}")
restLogger.Info("Successfuly deployed chainCode: " + chainID + ".\n")
}
// Register confirms the enrollmentID and secret password of the client with the
// CA and stores the enrollment certificate and key in the Devops server.
func (s *ServerOpenchainREST) Register(rw web.ResponseWriter, req *web.Request) {
restLogger.Info("REST client login...")
// Decode the incoming JSON payload
var loginSpec pb.Secret
err := jsonpb.Unmarshal(req.Body, &loginSpec)
// Check for proper JSON syntax
if err != nil {
// Unmarshall returns a " character around unrecognized fields in the case
// of a schema validation failure. These must be replaced with a ' character.
// Otherwise, the returned JSON is invalid.
errVal := strings.Replace(err.Error(), "\"", "'", -1)
// Client must supply payload
if err == io.EOF {
rw.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(rw, "{\"Error\": \"Payload must contain object Secret with enrollId and enrollSecret fields.\"}")
restLogger.Error("{\"Error\": \"Payload must contain object Secret with enrollId and enrollSecret fields.\"}")
} else {
rw.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(rw, "{\"Error\": \"%s\"}", errVal)
restLogger.Error(fmt.Sprintf("{\"Error\": \"%s\"}", errVal))
}
return
}
// Check that the enrollId and enrollSecret are not left blank.
if (loginSpec.EnrollId == "") || (loginSpec.EnrollSecret == "") {
rw.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(rw, "{\"Error\": \"enrollId and enrollSecret may not be blank.\"}")
restLogger.Error("{\"Error\": \"enrollId and enrollSecret may not be blank.\"}")
return
}
// Retrieve the REST data storage path
// Returns /var/openchain/production/client/
localStore := getRESTFilePath()
restLogger.Info("Local data store for client loginToken: %s", localStore)
// If the user is already logged in, return
if _, err := os.Stat(localStore + "loginToken_" + loginSpec.EnrollId); err == nil {
rw.WriteHeader(http.StatusOK)
fmt.Fprintf(rw, "{\"OK\": \"User %s is already logged in.\"}", loginSpec.EnrollId)
restLogger.Info("User '%s' is already logged in.\n", loginSpec.EnrollId)
return
}
// User is not logged in, proceed with login
restLogger.Info("Logging in user '%s' on REST interface...\n", loginSpec.EnrollId)
// Get a devopsClient to perform the login
clientConn, err := peer.NewPeerClientConnection()
if err != nil {
rw.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(rw, "{\"Error\": \"Error trying to connect to local peer: %s\"}", err)
restLogger.Error(fmt.Sprintf("Error trying to connect to local peer: %s", err))
return
}
devopsClient := pb.NewDevopsClient(clientConn)
// Perform the login
loginResult, err := devopsClient.Login(context.Background(), &loginSpec)
// Check if login is successful
if loginResult.Status == pb.Response_SUCCESS {
// If /var/openchain/production/client/ directory does not exist, create it
if _, err := os.Stat(localStore); err != nil {
if os.IsNotExist(err) {
// Directory does not exist, create it
if err := os.Mkdir(localStore, 0755); err != nil {
rw.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(rw, "{\"Error\": \"Fatal error -- %s\"}", err)
panic(fmt.Errorf("Fatal error when creating %s directory: %s\n", localStore, err))
}
} else {
// Unexpected error
rw.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(rw, "{\"Error\": \"Fatal error -- %s\"}", err)
panic(fmt.Errorf("Fatal error on os.Stat of %s directory: %s\n", localStore, err))
}
}
// Store client security context into a file
restLogger.Info("Storing login token for user '%s'.\n", loginSpec.EnrollId)
err = ioutil.WriteFile(localStore+"loginToken_"+loginSpec.EnrollId, []byte(loginSpec.EnrollId), 0755)
if err != nil {
rw.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(rw, "{\"Error\": \"Fatal error -- %s\"}", err)
panic(fmt.Errorf("Fatal error when storing client login token: %s\n", err))
}
rw.WriteHeader(http.StatusOK)
fmt.Fprintf(rw, "{\"OK\": \"Login successful for user '%s'.\"}", loginSpec.EnrollId)
restLogger.Info("Login successful for user '%s'.\n", loginSpec.EnrollId)
} else {
loginErr := strings.Replace(string(loginResult.Msg), "\"", "'", -1)
rw.WriteHeader(http.StatusUnauthorized)
fmt.Fprintf(rw, "{\"Error\": \"%s\"}", loginErr)
restLogger.Error(fmt.Sprintf("Error on client login: %s", loginErr))
}
return
}
func Cmds(address string) ([]*cobra.Command, error) {
marshaller := &jsonpb.Marshaler{Indent: " "}
job := &cobra.Command{
Use: "job",
Short: "Docs for jobs.",
Long: `Jobs are the basic unit of computation in Pachyderm.
Jobs run a containerized workload over a set of finished input commits.
Creating a job will also create a new repo and a commit in that repo which
contains the output of the job. Unless the job is created with another job as a
parent. If the job is created with a parent it will use the same repo as its
parent job and the commit it creates will use the parent job's commit as a
parent.
If the job fails the commit it creates will not be finished.
The increase the throughput of a job increase the Shard paremeter.
`,
Run: pkgcobra.RunFixedArgs(0, func(args []string) error {
return nil
}),
}
exampleCreateJobRequest, err := marshaller.MarshalToString(example.CreateJobRequest())
if err != nil {
return nil, err
}
var jobPath string
createJob := &cobra.Command{
Use: "create-job -f job.json",
Short: "Create a new job. Returns the id of the created job.",
Long: fmt.Sprintf("Create a new job from a spec, the spec looks like this\n%s", exampleCreateJobRequest),
Run: func(cmd *cobra.Command, args []string) {
apiClient, err := getAPIClient(address)
if err != nil {
errorAndExit("Error connecting to pps: %s", err.Error())
}
var jobReader io.Reader
if jobPath == "-" {
jobReader = os.Stdin
fmt.Print("Reading from stdin.\n")
} else {
jobFile, err := os.Open(jobPath)
if err != nil {
errorAndExit("Error opening %s: %s", jobPath, err.Error())
}
defer func() {
if err := jobFile.Close(); err != nil {
errorAndExit("Error closing%s: %s", jobPath, err.Error())
}
}()
jobReader = jobFile
}
var request pps.CreateJobRequest
if err := jsonpb.Unmarshal(jobReader, &request); err != nil {
errorAndExit("Error reading from stdin: %s", err.Error())
}
job, err := apiClient.CreateJob(
context.Background(),
&request,
)
if err != nil {
errorAndExit("Error from CreateJob: %s", err.Error())
}
fmt.Println(job.Id)
},
}
createJob.Flags().StringVarP(&jobPath, "file", "f", "-", "The file containing the job, - reads from stdin.")
inspectJob := &cobra.Command{
Use: "inspect-job job-id",
Short: "Return info about a job.",
Long: "Return info about a job.",
Run: pkgcobra.RunFixedArgs(1, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
jobInfo, err := apiClient.InspectJob(
context.Background(),
&pps.InspectJobRequest{
Job: &pps.Job{
Id: args[0],
},
},
)
if err != nil {
errorAndExit("Error from InspectJob: %s", err.Error())
}
if jobInfo == nil {
errorAndExit("Job %s not found.", args[0])
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintJobHeader(writer)
pretty.PrintJobInfo(writer, jobInfo)
return writer.Flush()
}),
}
var pipelineName string
listJob := &cobra.Command{
Use: "list-job -p pipeline-name",
Short: "Return info about all jobs.",
Long: "Return info about all jobs.",
Run: pkgcobra.RunFixedArgs(0, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
var pipeline *pps.Pipeline
if pipelineName != "" {
pipeline = &pps.Pipeline{
Name: pipelineName,
}
}
jobInfos, err := apiClient.ListJob(
context.Background(),
&pps.ListJobRequest{
Pipeline: pipeline,
},
)
if err != nil {
errorAndExit("Error from InspectJob: %s", err.Error())
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintJobHeader(writer)
for _, jobInfo := range jobInfos.JobInfo {
pretty.PrintJobInfo(writer, jobInfo)
}
return writer.Flush()
}),
}
listJob.Flags().StringVarP(&pipelineName, "pipeline", "p", "", "Limit to jobs made by pipeline.")
pipeline := &cobra.Command{
Use: "pipeline",
Short: "Docs for pipelines.",
Long: `Pipelines are a powerful abstraction for automating jobs.
Pipelines take a set of repos as inputs, rather than the set of commits that
jobs take. Pipelines then subscribe to commits on those repos and launches a job
to process each incoming commit.
Creating a pipeline will also create a repo of the same name.
All jobs created by a pipeline will create commits in the pipeline's repo.
`,
Run: pkgcobra.RunFixedArgs(0, func(args []string) error {
return nil
}),
}
var pipelinePath string
exampleCreatePipelineRequest, err := marshaller.MarshalToString(example.CreatePipelineRequest())
if err != nil {
return nil, err
}
createPipeline := &cobra.Command{
Use: "create-pipeline -f pipeline.json",
Short: "Create a new pipeline.",
Long: fmt.Sprintf("Create a new pipeline from a spec, the spec looks like this\n%s", exampleCreatePipelineRequest),
Run: func(cmd *cobra.Command, args []string) {
apiClient, err := getAPIClient(address)
if err != nil {
errorAndExit("Error connecting to pps: %s", err.Error())
}
var pipelineReader io.Reader
if pipelinePath == "-" {
pipelineReader = os.Stdin
fmt.Print("Reading from stdin.\n")
} else {
pipelineFile, err := os.Open(pipelinePath)
if err != nil {
errorAndExit("Error opening %s: %s", pipelinePath, err.Error())
}
defer func() {
if err := pipelineFile.Close(); err != nil {
errorAndExit("Error closing%s: %s", pipelinePath, err.Error())
}
}()
pipelineReader = pipelineFile
}
var request pps.CreatePipelineRequest
if err := jsonpb.Unmarshal(pipelineReader, &request); err != nil {
errorAndExit("Error reading from stdin: %s", err.Error())
}
if _, err := apiClient.CreatePipeline(
context.Background(),
&request,
); err != nil {
errorAndExit("Error from CreatePipeline: %s", err.Error())
}
},
}
createPipeline.Flags().StringVarP(&pipelinePath, "file", "f", "-", "The file containing the pipeline, - reads from stdin.")
inspectPipeline := &cobra.Command{
Use: "inspect-pipeline pipeline-name",
Short: "Return info about a pipeline.",
Long: "Return info about a pipeline.",
Run: pkgcobra.RunFixedArgs(1, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
pipelineInfo, err := apiClient.InspectPipeline(
context.Background(),
&pps.InspectPipelineRequest{
Pipeline: &pps.Pipeline{
Name: args[0],
},
},
)
if err != nil {
errorAndExit("Error from InspectPipeline: %s", err.Error())
}
if pipelineInfo == nil {
errorAndExit("Pipeline %s not found.", args[0])
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintPipelineHeader(writer)
pretty.PrintPipelineInfo(writer, pipelineInfo)
return writer.Flush()
}),
}
listPipeline := &cobra.Command{
Use: "list-pipeline",
Short: "Return info about all pipelines.",
Long: "Return info about all pipelines.",
Run: pkgcobra.RunFixedArgs(0, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
pipelineInfos, err := apiClient.ListPipeline(
context.Background(),
&pps.ListPipelineRequest{},
)
if err != nil {
errorAndExit("Error from ListPipeline: %s", err.Error())
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintPipelineHeader(writer)
for _, pipelineInfo := range pipelineInfos.PipelineInfo {
pretty.PrintPipelineInfo(writer, pipelineInfo)
}
return writer.Flush()
}),
}
deletePipeline := &cobra.Command{
Use: "delete-pipeline pipeline-name",
Short: "Delete a pipeline.",
Long: "Delete a pipeline.",
Run: pkgcobra.RunFixedArgs(1, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
if _, err := apiClient.DeletePipeline(
context.Background(),
&pps.DeletePipelineRequest{
Pipeline: &pps.Pipeline{
Name: args[0],
},
},
); err != nil {
errorAndExit("Error from DeletePipeline: %s", err.Error())
}
return nil
}),
}
var result []*cobra.Command
result = append(result, job)
result = append(result, createJob)
result = append(result, inspectJob)
result = append(result, listJob)
result = append(result, pipeline)
result = append(result, createPipeline)
result = append(result, inspectPipeline)
result = append(result, listPipeline)
result = append(result, deletePipeline)
return result, nil
}
func Cmds(address string) ([]*cobra.Command, error) {
marshaller := &jsonpb.Marshaler{Indent: " "}
exampleCreateJobRequest, err := marshaller.MarshalToString(example.CreateJobRequest())
if err != nil {
return nil, err
}
var jobPath string
createJob := &cobra.Command{
Use: "create-job -f job.json",
Short: "Create a new job. Returns the id of the created job.",
Long: fmt.Sprintf("Create a new job from a spec, the spec looks like this\n%s", exampleCreateJobRequest),
Run: func(cmd *cobra.Command, args []string) {
apiClient, err := getAPIClient(address)
if err != nil {
errorAndExit("Error connecting to pps: %s", err.Error())
}
var jobReader io.Reader
if jobPath == "-" {
jobReader = os.Stdin
fmt.Print("Reading from stdin.\n")
} else {
jobFile, err := os.Open(jobPath)
if err != nil {
errorAndExit("Error opening %s: %s", jobPath, err.Error())
}
defer func() {
if err := jobFile.Close(); err != nil {
errorAndExit("Error closing%s: %s", jobPath, err.Error())
}
}()
jobReader = jobFile
}
var request pps.CreateJobRequest
if err := jsonpb.Unmarshal(jobReader, &request); err != nil {
errorAndExit("Error reading from stdin: %s", err.Error())
}
job, err := apiClient.CreateJob(
context.Background(),
&request,
)
if err != nil {
errorAndExit("Error from CreateJob: %s", err.Error())
}
fmt.Println(job.Id)
},
}
createJob.Flags().StringVarP(&jobPath, "file", "f", "-", "The file containing the job, - reads from stdin.")
inspectJob := &cobra.Command{
Use: "inspect-job job-id",
Short: "Return info about a job.",
Long: "Return info about a job.",
Run: pkgcobra.RunFixedArgs(1, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
jobInfo, err := apiClient.InspectJob(
context.Background(),
&pps.InspectJobRequest{
Job: &pps.Job{
Id: args[0],
},
},
)
if err != nil {
errorAndExit("Error from InspectJob: %s", err.Error())
}
if jobInfo == nil {
errorAndExit("Job %s not found.", args[0])
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintJobHeader(writer)
pretty.PrintJobInfo(writer, jobInfo)
return writer.Flush()
}),
}
var pipelineName string
listJob := &cobra.Command{
Use: "list-job -p pipeline-name",
Short: "Return info about all jobs.",
Long: "Return info about all jobs.",
Run: pkgcobra.RunFixedArgs(0, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
var pipeline *pps.Pipeline
if pipelineName != "" {
pipeline = &pps.Pipeline{
Name: pipelineName,
}
}
jobInfos, err := apiClient.ListJob(
context.Background(),
&pps.ListJobRequest{
Pipeline: pipeline,
},
)
if err != nil {
errorAndExit("Error from InspectJob: %s", err.Error())
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintJobHeader(writer)
for _, jobInfo := range jobInfos.JobInfo {
pretty.PrintJobInfo(writer, jobInfo)
}
return writer.Flush()
}),
}
listJob.Flags().StringVarP(&pipelineName, "pipeline", "p", "", "Limit to jobs made by pipeline.")
var pipelinePath string
exampleCreatePipelineRequest, err := marshaller.MarshalToString(example.CreatePipelineRequest())
if err != nil {
return nil, err
}
createPipeline := &cobra.Command{
Use: "create-pipeline -f pipeline.json",
Short: "Create a new pipeline.",
Long: fmt.Sprintf("Create a new pipeline from a spec, the spec looks like this\n%s", exampleCreatePipelineRequest),
Run: func(cmd *cobra.Command, args []string) {
apiClient, err := getAPIClient(address)
if err != nil {
errorAndExit("Error connecting to pps: %s", err.Error())
}
var pipelineReader io.Reader
if pipelinePath == "-" {
pipelineReader = os.Stdin
fmt.Print("Reading from stdin.\n")
} else {
pipelineFile, err := os.Open(pipelinePath)
if err != nil {
errorAndExit("Error opening %s: %s", pipelinePath, err.Error())
}
defer func() {
if err := pipelineFile.Close(); err != nil {
errorAndExit("Error closing%s: %s", pipelinePath, err.Error())
}
}()
pipelineReader = pipelineFile
}
var request pps.CreatePipelineRequest
if err := jsonpb.Unmarshal(pipelineReader, &request); err != nil {
errorAndExit("Error reading from stdin: %s", err.Error())
}
if _, err := apiClient.CreatePipeline(
context.Background(),
&request,
); err != nil {
errorAndExit("Error from CreatePipeline: %s", err.Error())
}
},
}
createPipeline.Flags().StringVarP(&pipelinePath, "file", "f", "-", "The file containing the pipeline, - reads from stdin.")
inspectPipeline := &cobra.Command{
Use: "inspect-pipeline pipeline-name",
Short: "Return info about a pipeline.",
Long: "Return info about a pipeline.",
Run: pkgcobra.RunFixedArgs(1, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
pipelineInfo, err := apiClient.InspectPipeline(
context.Background(),
&pps.InspectPipelineRequest{
Pipeline: &pps.Pipeline{
Name: args[0],
},
},
)
if err != nil {
errorAndExit("Error from InspectPipeline: %s", err.Error())
}
if pipelineInfo == nil {
errorAndExit("Pipeline %s not found.", args[0])
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintPipelineHeader(writer)
pretty.PrintPipelineInfo(writer, pipelineInfo)
return writer.Flush()
}),
}
listPipeline := &cobra.Command{
Use: "list-pipeline",
Short: "Return info about all pipelines.",
Long: "Return info about all pipelines.",
Run: pkgcobra.RunFixedArgs(0, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
pipelineInfos, err := apiClient.ListPipeline(
context.Background(),
&pps.ListPipelineRequest{},
)
if err != nil {
errorAndExit("Error from ListPipeline: %s", err.Error())
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintPipelineHeader(writer)
for _, pipelineInfo := range pipelineInfos.PipelineInfo {
pretty.PrintPipelineInfo(writer, pipelineInfo)
}
return writer.Flush()
}),
}
deletePipeline := &cobra.Command{
Use: "delete-pipeline pipeline-name",
Short: "Delete a pipeline.",
Long: "Delete a pipeline.",
Run: pkgcobra.RunFixedArgs(1, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
if _, err := apiClient.DeletePipeline(
context.Background(),
&pps.DeletePipelineRequest{
Pipeline: &pps.Pipeline{
Name: args[0],
},
},
); err != nil {
errorAndExit("Error from DeletePipeline: %s", err.Error())
}
return nil
}),
}
var result []*cobra.Command
result = append(result, createJob)
result = append(result, inspectJob)
result = append(result, listJob)
result = append(result, createPipeline)
result = append(result, inspectPipeline)
result = append(result, listPipeline)
result = append(result, deletePipeline)
return result, nil
}
