Add remote_calendar{_test}.go

Allows creation of pending timestamps and updating them using
opentimestamps servers.

Author: OttoAllmendinger

opentimestamps/remote_calendar.go

@@ -0,0 +1,146 @@
+package opentimestamps
+
+import (
+	"bytes"
+	"encoding/hex"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/http/httputil"
+	"strings"
+
+	"github.com/Sirupsen/logrus"
+)
+
+const userAgent = "go-opentimestamps"
+
+const dumpResponse = false
+
+type RemoteCalendar struct {
+	baseURL string
+	client  *http.Client
+	log     *logrus.Logger
+}
+
+func NewRemoteCalendar(baseURL string) (*RemoteCalendar, error) {
+	// FIXME remove this
+	if baseURL == "localhost" {
+		baseURL = "http://localhost:14788"
+	}
+	// TODO validate url
+	if !strings.HasSuffix(baseURL, "/") {
+		baseURL += "/"
+	}
+	return &RemoteCalendar{
+		baseURL,
+		http.DefaultClient,
+		logrus.New(),
+	}, nil
+}
+
+// Check response status, return informational error message if
+// status is not `200 OK`.
+func checkStatusOK(resp *http.Response) error {
+	if resp.StatusCode == http.StatusOK {
+		return nil
+	}
+	errMsg := fmt.Sprintf("unexpected response: %q", resp.Status)
+	if resp.Body == nil {
+		return fmt.Errorf("%s (body=nil)", errMsg)
+	}
+	defer resp.Body.Close()
+	bodyBytes, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("%s (bodyErr=%v)", errMsg, err)
+	} else {
+		return fmt.Errorf("%s (body=%q)", errMsg, bodyBytes)
+	}
+}
+
+func (c *RemoteCalendar) do(r *http.Request) (*http.Response, error) {
+	r.Header.Add("Accept", "application/vnd.opentimestamps.v1")
+	r.Header.Add("User-Agent", userAgent)
+	c.log.Debugf("> %s %s", r.Method, r.URL)
+	resp, err := c.client.Do(r)
+	if err != nil {
+		c.log.Errorf("> %s %s error: %v", r.Method, r.URL, err)
+		return resp, err
+	}
+	c.log.Debugf("< %s %s - %v", r.Method, r.URL, resp.Status)
+	if dumpResponse {
+		bytes, err := httputil.DumpResponse(resp, true)
+		if err == nil {
+			c.log.Debugf("response dump:%s ", bytes)
+		}
+	}
+	return resp, err
+}
+
+func (c *RemoteCalendar) url(path string) string {
+	return c.baseURL + path
+}
+
+func (c *RemoteCalendar) Submit(digest []byte) (*Timestamp, error) {
+	body := bytes.NewBuffer(digest)
+	req, err := http.NewRequest("POST", c.url("digest"), body)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := c.do(req)
+	if err != nil {
+		return nil, err
+	}
+	if resp.Body != nil {
+		defer resp.Body.Close()
+	}
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("expected 200, got %v", resp.Status)
+	}
+	return NewTimestampFromReader(resp.Body, digest)
+}
+
+func (c *RemoteCalendar) GetTimestamp(commitment []byte) (*Timestamp, error) {
+	url := c.url("timestamp/" + hex.EncodeToString(commitment))
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := c.do(req)
+	if err != nil {
+		return nil, err
+	}
+	if err := checkStatusOK(resp); err != nil {
+		return nil, err
+	}
+	if resp.Body != nil {
+		defer resp.Body.Close()
+	}
+	return NewTimestampFromReader(resp.Body, commitment)
+}
+
+type PendingTimestamp struct {
+	Timestamp          *Timestamp
+	PendingAttestation *pendingAttestation
+}
+
+func (p PendingTimestamp) Upgrade() (*Timestamp, error) {
+	cal, err := NewRemoteCalendar(p.PendingAttestation.uri)
+	if err != nil {
+		return nil, err
+	}
+	return cal.GetTimestamp(p.Timestamp.Message)
+}
+
+func PendingTimestamps(ts *Timestamp) (res []PendingTimestamp) {
+	ts.Walk(func(ts *Timestamp) {
+		for _, att := range ts.Attestations {
+			p, ok := att.(*pendingAttestation)
+			if !ok {
+				continue
+			}
+			attCopy := *p
+			res = append(res, PendingTimestamp{ts, &attCopy})
+		}
+	})
+	return
+}

opentimestamps/remote_calendar_test.go

@@ -0,0 +1,69 @@
+package opentimestamps
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/Sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+const calendarServerEnvvar = "GOTS_TEST_CALENDAR_SERVER"
+const bitcoinRegtestEnvvar = "GOTS_TEST_BITCOIN_REGTEST_SERVER"
+
+func newTestCalendar(url string) *RemoteCalendar {
+	logrus.SetLevel(logrus.DebugLevel)
+	cal, err := NewRemoteCalendar(url)
+	if err != nil {
+		panic("could not create test calendar")
+	}
+	cal.log.Level = logrus.DebugLevel
+	return cal
+}
+
+func newTestDigest(in string) []byte {
+	hash := sha256.Sum256([]byte(in))
+	return hash[:]
+}
+
+func TestRemoteCalendarExample(t *testing.T) {
+	dts, err := NewDetachedTimestampFromPath(
+		"../examples/two-calendars.txt.ots",
+	)
+	require.NoError(t, err)
+
+	pts := PendingTimestamps(dts.Timestamp)
+	assert.Equal(t, 2, len(pts))
+	for _, pt := range pts {
+		ts, err := pt.Upgrade()
+		assert.NoError(t, err)
+		fmt.Print(ts.Dump())
+	}
+}
+
+func TestRemoteCalendarRoundTrip(t *testing.T) {
+	calendarServer := os.Getenv(calendarServerEnvvar)
+	if calendarServer == "" {
+		t.Skipf("%q not set, skipping test", calendarServerEnvvar)
+	}
+	cal := newTestCalendar(calendarServer)
+	ts, err := cal.Submit(newTestDigest("Hello, World!"))
+	require.NoError(t, err)
+	require.NotNil(t, ts)
+
+	// TODO call btcrpcclient generateblock 100
+
+	// FIXME possible opentimestamps-server bug?
+	// wait until attestation has been aggregated
+	time.Sleep(2 * time.Second)
+
+	for _, pts := range PendingTimestamps(ts) {
+		ts, err := pts.Upgrade()
+		assert.NoError(t, err)
+		_ = ts
+	}
+}