add implementation of http/https protocol

Signed-off-by: allen.wq <[email protected]>

Author: wangforthinker

pkg/protocol/http/http.go

@@ -0,0 +1,108 @@
+/*
+ * Copyright The Dragonfly Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package http
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/dragonflyoss/Dragonfly/pkg/errortypes"
+	"github.com/dragonflyoss/Dragonfly/pkg/protocol"
+)
+
+var (
+	// DefaultClientOpt is default implementation of ClientOpt.
+	DefaultClientOpt = &ClientOpt{
+		transport: http.DefaultTransport,
+	}
+
+	// DefaultClient is default implementation of Client.
+	DefaultClient = &Client{
+		client:    &http.Client{Transport: DefaultClientOpt.transport},
+		transport: DefaultClientOpt.transport,
+	}
+)
+
+const (
+	// http protocol name
+	ProtocolHTTPName = "http"
+
+	// https protocol name
+	ProtocolHTTPSName = "https"
+)
+
+func init() {
+	protocol.RegisterProtocol(ProtocolHTTPName, &ClientBuilder{})
+	protocol.RegisterProtocol(ProtocolHTTPSName, &ClientBuilder{supportHTTPS: true})
+}
+
+// ClientOpt is the argument of NewProtocolClient.
+type ClientOpt struct {
+	transport http.RoundTripper
+}
+
+var _ protocol.Client = &Client{}
+
+// Client is an implementation of protocol.Client for http protocol.
+type Client struct {
+	client    *http.Client
+	transport http.RoundTripper
+}
+
+func (cli *Client) GetResource(url string, md protocol.Metadata) protocol.Resource {
+	var (
+		hd *Headers
+	)
+
+	if md != nil {
+		h, ok := md.(*Headers)
+		if ok {
+			hd = h
+		}
+	}
+
+	return &Resource{
+		url:    url,
+		hd:     hd,
+		client: cli,
+	}
+}
+
+// ClientBuilder is an implementation of protocol.ClientBuilder for http protocol.
+type ClientBuilder struct {
+	supportHTTPS bool
+}
+
+func (cb *ClientBuilder) NewProtocolClient(clientOpt interface{}) (protocol.Client, error) {
+	if clientOpt == nil {
+		if cb.supportHTTPS {
+			return nil, fmt.Errorf("clientOpt should be set for https")
+		}
+
+		clientOpt = DefaultClientOpt
+	}
+
+	opt, ok := clientOpt.(*ClientOpt)
+	if !ok {
+		return nil, errortypes.ErrConvertFailed
+	}
+
+	return &Client{
+		client:    &http.Client{Transport: opt.transport},
+		transport: opt.transport,
+	}, nil
+}

pkg/protocol/http/md.go

@@ -0,0 +1,51 @@
+/*
+ * Copyright The Dragonfly Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package http
+
+import (
+	"net/http"
+
+	"github.com/dragonflyoss/Dragonfly/pkg/protocol"
+)
+
+// NewHTTPMetaData generates an instance of protocol.Metadata.
+func NewHTTPMetaData() protocol.Metadata {
+	return &Headers{
+		Header: make(http.Header),
+	}
+}
+
+// Headers is an implementation of protocol.Metadata.
+type Headers struct {
+	http.Header
+}
+
+func (hd *Headers) Get(key string) (interface{}, error) {
+	return hd.Header.Get(key), nil
+}
+
+func (hd *Headers) Set(key string, value interface{}) {
+	hd.Header.Set(key, value.(string))
+}
+
+func (hd *Headers) Del(key string) {
+	hd.Header.Del(key)
+}
+
+func (hd *Headers) All() interface{} {
+	return hd.Header
+}

pkg/protocol/http/md_test.go

@@ -0,0 +1,65 @@
+/*
+ * Copyright The Dragonfly Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package http
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/dragonflyoss/Dragonfly/dfget/core/helper"
+
+	"github.com/go-check/check"
+)
+
+func Test(t *testing.T) {
+	check.TestingT(t)
+}
+
+type HTTPSuite struct {
+	host   string
+	port   int
+	server *helper.MockFileServer
+}
+
+func init() {
+	check.Suite(&HTTPSuite{})
+}
+
+func (suite *HTTPSuite) TestMd(c *check.C) {
+	md := NewHTTPMetaData()
+	md.Set("k1", "v1")
+	md.Set("k2", "v2")
+
+	v1, err := md.Get("k1")
+	c.Assert(err, check.IsNil)
+	c.Assert(v1.(string), check.Equals, "v1")
+
+	v2, err := md.Get("k2")
+	c.Assert(err, check.IsNil)
+	c.Assert(v2.(string), check.Equals, "v2")
+
+	md.Del("k1")
+	v1, err = md.Get("k1")
+	c.Assert(err, check.IsNil)
+	c.Assert(v1.(string), check.Equals, "")
+
+	hd, ok := md.All().(http.Header)
+	c.Assert(ok, check.Equals, true)
+
+	v2 = hd.Get("k2")
+	c.Assert(v2, check.Equals, "v2")
+}

pkg/protocol/http/resource.go

@@ -0,0 +1,134 @@
+/*
+ * Copyright The Dragonfly Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package http
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/dragonflyoss/Dragonfly/dfget/config"
+	"github.com/dragonflyoss/Dragonfly/pkg/protocol"
+)
+
+// Resource is an implementation of protocol.Resource for http protocol.
+type Resource struct {
+	url    string
+	hd     *Headers
+	client *Client
+}
+
+func (rs *Resource) Read(ctx context.Context, off int64, size int64) (rc io.ReadCloser, err error) {
+	req, err := rs.newRequest(ctx, off, size)
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := rs.doRequest(req)
+	if err != nil {
+		return nil, err
+	}
+
+	defer func() {
+		if err != nil && res.Body != nil {
+			res.Body.Close()
+		}
+	}()
+
+	if res.StatusCode != http.StatusOK && res.StatusCode != http.StatusPartialContent {
+		return nil, fmt.Errorf("respnose code is not 200 or 206")
+	}
+
+	return res.Body, nil
+}
+
+func (rs *Resource) Length(ctx context.Context) (int64, error) {
+	timeoutCtx, cancel := context.WithTimeout(ctx, 3*time.Second)
+	defer cancel()
+
+	req, err := rs.newRequest(timeoutCtx, 0, 0)
+	if err != nil {
+		return 0, err
+	}
+
+	res, err := rs.doRequest(req)
+	if err != nil {
+		return 0, err
+	}
+
+	defer res.Body.Close()
+	lenStr := res.Header.Get(config.StrContentLength)
+	if lenStr == "" {
+		return 0, fmt.Errorf("failed to get content length")
+	}
+
+	length, err := strconv.ParseInt(lenStr, 10, 64)
+	if err != nil {
+		return 0, fmt.Errorf("failed to prase %s to length: %sv", lenStr, err)
+	}
+
+	return length, nil
+}
+
+func (rs *Resource) Metadata(ctx context.Context) (protocol.Metadata, error) {
+	return rs.hd, nil
+}
+
+func (rs *Resource) Expire(ctx context.Context) (bool, interface{}, error) {
+	// need to implementation
+	return false, nil, nil
+}
+
+func (rs *Resource) Call(ctx context.Context, request interface{}) (response interface{}, err error) {
+	return nil, protocol.ErrNotImplementation
+}
+
+func (rs *Resource) Close() error {
+	return nil
+}
+
+func (rs *Resource) newRequest(ctx context.Context, off, size int64) (*http.Request, error) {
+	// off == 0 && size == 0 means all data.
+	if (off < 0 || size < 0) || (off > 0 && size == 0) {
+		return nil, fmt.Errorf("invalid argument")
+	}
+
+	req, err := http.NewRequest(http.MethodGet, rs.url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	if rs.hd != nil {
+		for k, v := range rs.hd.Header {
+			req.Header.Set(k, v[0])
+		}
+	}
+
+	if size > 0 {
+		req.Header.Set(config.StrRange, fmt.Sprintf("bytes=%d-%d", off, off+size-1))
+	}
+
+	req = req.WithContext(ctx)
+	return req, nil
+}
+
+func (rs *Resource) doRequest(req *http.Request) (*http.Response, error) {
+	return rs.client.client.Do(req)
+}