diff --git a/cmd/fileTransfer.go b/cmd/fileTransfer.go
index e11e320de7c44ae9fb164cb7b1160090df8fc80f..bccc9268c988c1c9ca1a12b60e20915e87679b4b 100644
--- a/cmd/fileTransfer.go
+++ b/cmd/fileTransfer.go
@@ -16,8 +16,8 @@ import (
"github.com/spf13/cobra"
jww "github.com/spf13/jwalterweatherman"
"github.com/spf13/viper"
- ft "gitlab.com/elixxir/client/fileTransfer2"
- ftE2e "gitlab.com/elixxir/client/fileTransfer2/e2e"
+ ft "gitlab.com/elixxir/client/fileTransfer"
+ ftE2e "gitlab.com/elixxir/client/fileTransfer/e2e"
"gitlab.com/elixxir/crypto/contact"
ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
"gitlab.com/xx_network/primitives/id"
diff --git a/cmix/gateway/storeHostList.go b/cmix/gateway/storeHostList.go
index 9d635005ef28301720257a329533cbf87f60be68..d71d17b53e235ad5eb02860d8951794304ed59cc 100644
--- a/cmix/gateway/storeHostList.go
+++ b/cmix/gateway/storeHostList.go
@@ -5,13 +5,6 @@
// LICENSE file //
////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
package gateway
import (
diff --git a/cmix/gateway/storeHostList_test.go b/cmix/gateway/storeHostList_test.go
index a0fe45c34acfa906d0f3c53b73bdbab4e40022fb..6dddef1f25f0737cda09b8b53802d4431806bd0b 100644
--- a/cmix/gateway/storeHostList_test.go
+++ b/cmix/gateway/storeHostList_test.go
@@ -5,13 +5,6 @@
// LICENSE file //
////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
package gateway
import (
diff --git a/fileTransfer/batchBuilder.go b/fileTransfer/batchBuilder.go
index 005c7f93827ecbc8d4178f7c0b356d184c621ccf..24749e77ad9c16deff40c2e489fd4a7f3f34ce08 100644
--- a/fileTransfer/batchBuilder.go
+++ b/fileTransfer/batchBuilder.go
@@ -12,7 +12,9 @@ import (
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/fileTransfer/store"
"gitlab.com/elixxir/client/stoppable"
+ "gitlab.com/elixxir/crypto/cyclic"
"gitlab.com/elixxir/crypto/fastRNG"
+ "gitlab.com/elixxir/primitives/format"
"gitlab.com/xx_network/crypto/csprng"
"go.uber.org/ratelimit"
"time"
@@ -27,14 +29,10 @@ const (
// batchBuilderThread creates batches of file parts as they become available and
// buffer them to send. Also rate limits adding to the buffer.
func (m *manager) batchBuilderThread(stop *stoppable.Single) {
- // Calculate the average amount of data sent via SendManyCMIX
- avgNumMessages := (minPartsSendPerRound + maxPartsSendPerRound) / 2
- avgSendSize := avgNumMessages * 8192
-
// Calculate rate and make rate limiter
- rate := m.params.MaxThroughput / avgSendSize
- rl := ratelimit.New(rate, ratelimit.WithoutSlack)
+ rl := newRateLimiter(m.params.MaxThroughput, m.cmixGroup)
+ // Build each batch and add to the queue
for {
numParts := generateRandomPacketSize(m.rng)
packet := make([]store.Part, 0, numParts)
@@ -62,6 +60,53 @@ func (m *manager) batchBuilderThread(stop *stoppable.Single) {
}
}
+// newRateLimiter generates a new ratelimit.Limiter that limits the bandwidth to
+// the given max throughput (in bytes per second).
+func newRateLimiter(
+ maxThroughput int, cmixGroup *cyclic.Group) ratelimit.Limiter {
+ // Calculate rate and make rate limiter if max throughput is set
+ if maxThroughput > 0 {
+ // Calculate the average amount of data sent in each batch
+ messageSize := format.NewMessage(cmixGroup.GetP().ByteLen()).ContentsSize()
+ avgNumMessages := (minPartsSendPerRound + maxPartsSendPerRound) / 2
+ avgSendSize := avgNumMessages * messageSize
+
+ jww.DEBUG.Printf("[FT] Rate limiting parameters: message size: %d, "+
+ "average number of messages per send: %d, average size of send: %d",
+ messageSize, avgNumMessages, avgSendSize)
+
+ // Calculate the time window needed to achieve the desired bandwidth
+ per := time.Second
+ switch {
+ case avgSendSize < maxThroughput:
+ per = time.Second
+ case avgSendSize < maxThroughput*60:
+ per = time.Minute
+ case avgSendSize < maxThroughput*60*60:
+ per = time.Hour
+ case avgSendSize < maxThroughput*60*60*24:
+ per = time.Hour * 24
+ case avgSendSize < maxThroughput*60*60*24*7:
+ per = time.Hour * 24 * 7
+ }
+
+ // Calculate the rate of messages per time window
+ rate := int((float64(maxThroughput) / float64(avgSendSize)) *
+ float64(per/time.Second))
+
+ jww.INFO.Printf("[FT] Max throughput is %d bytes/second. "+
+ "File transfer will be rate limited to %d per %s.",
+ maxThroughput, rate, per)
+
+ return ratelimit.New(rate, ratelimit.WithoutSlack, ratelimit.Per(per))
+ }
+
+ // If the max throughput is zero, then create an unlimited rate limiter
+ jww.WARN.Printf("[FT] Max throughput is %d bytes/second. "+
+ "File transfer will not be rate limited.", maxThroughput)
+ return ratelimit.NewUnlimited()
+}
+
// generateRandomPacketSize returns a random number between minPartsSendPerRound
// and maxPartsSendPerRound, inclusive.
func generateRandomPacketSize(rngGen *fastRNG.StreamGenerator) int {
diff --git a/fileTransfer/callbackTracker/callbackTracker_test.go b/fileTransfer/callbackTracker/callbackTracker_test.go
index f14d368ee0fb6fbaa0ef9bdd1c2ac4b17c511755..7ffbe6636f3bc8abd56db36befbc699bfba22181 100644
--- a/fileTransfer/callbackTracker/callbackTracker_test.go
+++ b/fileTransfer/callbackTracker/callbackTracker_test.go
@@ -54,7 +54,7 @@ func Test_callbackTracker_call(t *testing.T) {
if r != nil {
t.Errorf("Received error: %+v", r)
}
- case <-time.After(25 * time.Millisecond):
+ case <-time.After(35 * time.Millisecond):
t.Error("Timed out waiting for callback.")
}
@@ -66,7 +66,7 @@ func Test_callbackTracker_call(t *testing.T) {
case <-cbChan:
t.Error("Callback called too soon.")
- case <-time.After(25 * time.Millisecond):
+ case <-time.After(35 * time.Millisecond):
ct.mux.RLock()
if !ct.scheduled {
t.Error("Callback is not scheduled when it should be.")
@@ -99,7 +99,7 @@ func Test_callbackTracker_call(t *testing.T) {
if !ct.complete {
t.Error("Callback is not marked complete when it should be.")
}
- case <-time.After(ct.period + 15*time.Millisecond):
+ case <-time.After(ct.period + 25*time.Millisecond):
t.Errorf("Callback not called after period %s.",
ct.period+15*time.Millisecond)
}
diff --git a/fileTransfer2/connect/listener.go b/fileTransfer/connect/listener.go
similarity index 100%
rename from fileTransfer2/connect/listener.go
rename to fileTransfer/connect/listener.go
diff --git a/fileTransfer2/connect/params.go b/fileTransfer/connect/params.go
similarity index 100%
rename from fileTransfer2/connect/params.go
rename to fileTransfer/connect/params.go
diff --git a/fileTransfer2/connect/send.go b/fileTransfer/connect/send.go
similarity index 98%
rename from fileTransfer2/connect/send.go
rename to fileTransfer/connect/send.go
index 12618c512be783f19962b4f897638684226cadf9..0d2b2a56113bd5604d866716e3f080959ab68743 100644
--- a/fileTransfer2/connect/send.go
+++ b/fileTransfer/connect/send.go
@@ -12,7 +12,7 @@ import (
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/catalog"
"gitlab.com/elixxir/client/e2e"
- ft "gitlab.com/elixxir/client/fileTransfer2"
+ ft "gitlab.com/elixxir/client/fileTransfer"
)
// Error messages.
diff --git a/fileTransfer2/connect/utils_test.go b/fileTransfer/connect/utils_test.go
similarity index 100%
rename from fileTransfer2/connect/utils_test.go
rename to fileTransfer/connect/utils_test.go
diff --git a/fileTransfer2/connect/wrapper.go b/fileTransfer/connect/wrapper.go
similarity index 99%
rename from fileTransfer2/connect/wrapper.go
rename to fileTransfer/connect/wrapper.go
index 19baf1fb59ebece52c7a128c7b742c6fbe4f588d..fa78ee94b75879898f0dcfcefc67b1038bd11991 100644
--- a/fileTransfer2/connect/wrapper.go
+++ b/fileTransfer/connect/wrapper.go
@@ -11,7 +11,7 @@ import (
"gitlab.com/elixxir/client/catalog"
"gitlab.com/elixxir/client/e2e"
"gitlab.com/elixxir/client/e2e/receive"
- ft "gitlab.com/elixxir/client/fileTransfer2"
+ ft "gitlab.com/elixxir/client/fileTransfer"
e2eCrypto "gitlab.com/elixxir/crypto/e2e"
ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
"gitlab.com/xx_network/primitives/id"
diff --git a/fileTransfer2/connect/wrapper_test.go b/fileTransfer/connect/wrapper_test.go
similarity index 99%
rename from fileTransfer2/connect/wrapper_test.go
rename to fileTransfer/connect/wrapper_test.go
index 686580a2a560b713b51e5ade85b1d5e04718f78d..a7967fdcdc296c9124286d18b4f1df5be6986993 100644
--- a/fileTransfer2/connect/wrapper_test.go
+++ b/fileTransfer/connect/wrapper_test.go
@@ -12,7 +12,7 @@ import (
"gitlab.com/elixxir/client/catalog"
"gitlab.com/elixxir/client/connect"
"gitlab.com/elixxir/client/e2e/receive"
- ft "gitlab.com/elixxir/client/fileTransfer2"
+ ft "gitlab.com/elixxir/client/fileTransfer"
"gitlab.com/elixxir/crypto/fastRNG"
ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
"gitlab.com/xx_network/crypto/csprng"
diff --git a/fileTransfer2/e2e/listener.go b/fileTransfer/e2e/listener.go
similarity index 100%
rename from fileTransfer2/e2e/listener.go
rename to fileTransfer/e2e/listener.go
diff --git a/fileTransfer2/e2e/params.go b/fileTransfer/e2e/params.go
similarity index 100%
rename from fileTransfer2/e2e/params.go
rename to fileTransfer/e2e/params.go
diff --git a/fileTransfer2/e2e/send.go b/fileTransfer/e2e/send.go
similarity index 98%
rename from fileTransfer2/e2e/send.go
rename to fileTransfer/e2e/send.go
index 54deb4e7e13990d48c9ac775f47cc27986556c23..8719e0b7bc582e753918ffda876a9da31a3f8bba 100644
--- a/fileTransfer2/e2e/send.go
+++ b/fileTransfer/e2e/send.go
@@ -12,7 +12,7 @@ import (
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/catalog"
"gitlab.com/elixxir/client/e2e"
- ft "gitlab.com/elixxir/client/fileTransfer2"
+ ft "gitlab.com/elixxir/client/fileTransfer"
"gitlab.com/xx_network/primitives/id"
)
diff --git a/fileTransfer2/e2e/utils_test.go b/fileTransfer/e2e/utils_test.go
similarity index 100%
rename from fileTransfer2/e2e/utils_test.go
rename to fileTransfer/e2e/utils_test.go
diff --git a/fileTransfer2/e2e/wrapper.go b/fileTransfer/e2e/wrapper.go
similarity index 99%
rename from fileTransfer2/e2e/wrapper.go
rename to fileTransfer/e2e/wrapper.go
index 3f8247de26e37ea2a1dee896a2a40211385c4a9c..e77681000d090e8cd9100f7d65bbea1500f50eeb 100644
--- a/fileTransfer2/e2e/wrapper.go
+++ b/fileTransfer/e2e/wrapper.go
@@ -11,7 +11,7 @@ import (
"gitlab.com/elixxir/client/catalog"
"gitlab.com/elixxir/client/e2e"
"gitlab.com/elixxir/client/e2e/receive"
- ft "gitlab.com/elixxir/client/fileTransfer2"
+ ft "gitlab.com/elixxir/client/fileTransfer"
e2eCrypto "gitlab.com/elixxir/crypto/e2e"
ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
"gitlab.com/xx_network/primitives/id"
diff --git a/fileTransfer2/e2e/wrapper_test.go b/fileTransfer/e2e/wrapper_test.go
similarity index 99%
rename from fileTransfer2/e2e/wrapper_test.go
rename to fileTransfer/e2e/wrapper_test.go
index 92133edc5da3c52e0335ea7081f8948a5096f000..cbe8230f44f08f778c5b1664f6dc622d71184b7f 100644
--- a/fileTransfer2/e2e/wrapper_test.go
+++ b/fileTransfer/e2e/wrapper_test.go
@@ -12,7 +12,7 @@ import (
"gitlab.com/elixxir/client/catalog"
"gitlab.com/elixxir/client/e2e"
"gitlab.com/elixxir/client/e2e/receive"
- ft "gitlab.com/elixxir/client/fileTransfer2"
+ ft "gitlab.com/elixxir/client/fileTransfer"
"gitlab.com/elixxir/crypto/fastRNG"
ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
"gitlab.com/xx_network/crypto/csprng"
diff --git a/fileTransfer/ftMessages.pb.go b/fileTransfer/ftMessages.pb.go
index 0663a60be474e3988c9efc4173ae74413da3257a..7990ffe025c93eb8a97dd303bcd2e85bbeec2b24 100644
--- a/fileTransfer/ftMessages.pb.go
+++ b/fileTransfer/ftMessages.pb.go
@@ -1,220 +1,149 @@
-///////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-///////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+// Copyright © 2020 xx network SEZC //
+// //
+// Use of this source code is governed by a license that can be found in the //
+// LICENSE file //
+////////////////////////////////////////////////////////////////////////////////
// Code generated by protoc-gen-go. DO NOT EDIT.
-// versions:
-// protoc-gen-go v1.26.0
-// protoc v3.17.3
// source: fileTransfer/ftMessages.proto
package fileTransfer
import (
- protoreflect "google.golang.org/protobuf/reflect/protoreflect"
- protoimpl "google.golang.org/protobuf/runtime/protoimpl"
- reflect "reflect"
- sync "sync"
+ fmt "fmt"
+ proto "github.com/golang/protobuf/proto"
+ math "math"
)
-const (
- // Verify that this generated code is sufficiently up-to-date.
- _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
- // Verify that runtime/protoimpl is sufficiently up-to-date.
- _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
-)
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
// NewFileTransfer is transmitted first on the initialization of a file transfer
// to inform the receiver about the incoming file.
type NewFileTransfer struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
-
- FileName string `protobuf:"bytes,1,opt,name=fileName,proto3" json:"fileName,omitempty"` // Name of the file; max 48 characters
- FileType string `protobuf:"bytes,2,opt,name=fileType,proto3" json:"fileType,omitempty"` // Tag of file; max 8 characters
- TransferKey []byte `protobuf:"bytes,3,opt,name=transferKey,proto3" json:"transferKey,omitempty"` // 256 bit encryption key to identify the transfer
- TransferMac []byte `protobuf:"bytes,4,opt,name=transferMac,proto3" json:"transferMac,omitempty"` // 256 bit MAC of the entire file
- NumParts uint32 `protobuf:"varint,5,opt,name=numParts,proto3" json:"numParts,omitempty"` // Number of file parts
- Size uint32 `protobuf:"varint,6,opt,name=size,proto3" json:"size,omitempty"` // The size of the file; max of 4 mB
- Retry float32 `protobuf:"fixed32,7,opt,name=retry,proto3" json:"retry,omitempty"` // Used to determine how many times to retry sending
- Preview []byte `protobuf:"bytes,8,opt,name=preview,proto3" json:"preview,omitempty"` // A preview of the file; max of 4 kB
-}
-
-func (x *NewFileTransfer) Reset() {
- *x = NewFileTransfer{}
- if protoimpl.UnsafeEnabled {
- mi := &file_fileTransfer_ftMessages_proto_msgTypes[0]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ FileName string `protobuf:"bytes,1,opt,name=fileName,proto3" json:"fileName,omitempty"`
+ FileType string `protobuf:"bytes,2,opt,name=fileType,proto3" json:"fileType,omitempty"`
+ TransferKey []byte `protobuf:"bytes,3,opt,name=transferKey,proto3" json:"transferKey,omitempty"`
+ TransferMac []byte `protobuf:"bytes,4,opt,name=transferMac,proto3" json:"transferMac,omitempty"`
+ NumParts uint32 `protobuf:"varint,5,opt,name=numParts,proto3" json:"numParts,omitempty"`
+ Size uint32 `protobuf:"varint,6,opt,name=size,proto3" json:"size,omitempty"`
+ Retry float32 `protobuf:"fixed32,7,opt,name=retry,proto3" json:"retry,omitempty"`
+ Preview []byte `protobuf:"bytes,8,opt,name=preview,proto3" json:"preview,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *NewFileTransfer) Reset() { *m = NewFileTransfer{} }
+func (m *NewFileTransfer) String() string { return proto.CompactTextString(m) }
+func (*NewFileTransfer) ProtoMessage() {}
+func (*NewFileTransfer) Descriptor() ([]byte, []int) {
+ return fileDescriptor_9d574f363dd34365, []int{0}
}
-func (x *NewFileTransfer) String() string {
- return protoimpl.X.MessageStringOf(x)
+func (m *NewFileTransfer) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_NewFileTransfer.Unmarshal(m, b)
}
-
-func (*NewFileTransfer) ProtoMessage() {}
-
-func (x *NewFileTransfer) ProtoReflect() protoreflect.Message {
- mi := &file_fileTransfer_ftMessages_proto_msgTypes[0]
- if protoimpl.UnsafeEnabled && x != nil {
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- if ms.LoadMessageInfo() == nil {
- ms.StoreMessageInfo(mi)
- }
- return ms
- }
- return mi.MessageOf(x)
+func (m *NewFileTransfer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_NewFileTransfer.Marshal(b, m, deterministic)
}
-
-// Deprecated: Use NewFileTransfer.ProtoReflect.Descriptor instead.
-func (*NewFileTransfer) Descriptor() ([]byte, []int) {
- return file_fileTransfer_ftMessages_proto_rawDescGZIP(), []int{0}
+func (m *NewFileTransfer) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_NewFileTransfer.Merge(m, src)
+}
+func (m *NewFileTransfer) XXX_Size() int {
+ return xxx_messageInfo_NewFileTransfer.Size(m)
+}
+func (m *NewFileTransfer) XXX_DiscardUnknown() {
+ xxx_messageInfo_NewFileTransfer.DiscardUnknown(m)
}
-func (x *NewFileTransfer) GetFileName() string {
- if x != nil {
- return x.FileName
+var xxx_messageInfo_NewFileTransfer proto.InternalMessageInfo
+
+func (m *NewFileTransfer) GetFileName() string {
+ if m != nil {
+ return m.FileName
}
return ""
}
-func (x *NewFileTransfer) GetFileType() string {
- if x != nil {
- return x.FileType
+func (m *NewFileTransfer) GetFileType() string {
+ if m != nil {
+ return m.FileType
}
return ""
}
-func (x *NewFileTransfer) GetTransferKey() []byte {
- if x != nil {
- return x.TransferKey
+func (m *NewFileTransfer) GetTransferKey() []byte {
+ if m != nil {
+ return m.TransferKey
}
return nil
}
-func (x *NewFileTransfer) GetTransferMac() []byte {
- if x != nil {
- return x.TransferMac
+func (m *NewFileTransfer) GetTransferMac() []byte {
+ if m != nil {
+ return m.TransferMac
}
return nil
}
-func (x *NewFileTransfer) GetNumParts() uint32 {
- if x != nil {
- return x.NumParts
+func (m *NewFileTransfer) GetNumParts() uint32 {
+ if m != nil {
+ return m.NumParts
}
return 0
}
-func (x *NewFileTransfer) GetSize() uint32 {
- if x != nil {
- return x.Size
+func (m *NewFileTransfer) GetSize() uint32 {
+ if m != nil {
+ return m.Size
}
return 0
}
-func (x *NewFileTransfer) GetRetry() float32 {
- if x != nil {
- return x.Retry
+func (m *NewFileTransfer) GetRetry() float32 {
+ if m != nil {
+ return m.Retry
}
return 0
}
-func (x *NewFileTransfer) GetPreview() []byte {
- if x != nil {
- return x.Preview
+func (m *NewFileTransfer) GetPreview() []byte {
+ if m != nil {
+ return m.Preview
}
return nil
}
-var File_fileTransfer_ftMessages_proto protoreflect.FileDescriptor
-
-var file_fileTransfer_ftMessages_proto_rawDesc = []byte{
- 0x0a, 0x1d, 0x66, 0x69, 0x6c, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x66,
- 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12,
- 0x05, 0x70, 0x61, 0x72, 0x73, 0x65, 0x22, 0xed, 0x01, 0x0a, 0x0f, 0x4e, 0x65, 0x77, 0x46, 0x69,
- 0x6c, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69,
- 0x6c, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69,
- 0x6c, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x54, 0x79,
- 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x54, 0x79,
- 0x70, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x4b, 0x65,
- 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65,
- 0x72, 0x4b, 0x65, 0x79, 0x12, 0x20, 0x0a, 0x0b, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72,
- 0x4d, 0x61, 0x63, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x74, 0x72, 0x61, 0x6e, 0x73,
- 0x66, 0x65, 0x72, 0x4d, 0x61, 0x63, 0x12, 0x1a, 0x0a, 0x08, 0x6e, 0x75, 0x6d, 0x50, 0x61, 0x72,
- 0x74, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x6e, 0x75, 0x6d, 0x50, 0x61, 0x72,
- 0x74, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d,
- 0x52, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x72, 0x65, 0x74, 0x72, 0x79, 0x18,
- 0x07, 0x20, 0x01, 0x28, 0x02, 0x52, 0x05, 0x72, 0x65, 0x74, 0x72, 0x79, 0x12, 0x18, 0x0a, 0x07,
- 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x70,
- 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x42, 0x0f, 0x5a, 0x0d, 0x66, 0x69, 0x6c, 0x65, 0x54, 0x72,
- 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-}
-
-var (
- file_fileTransfer_ftMessages_proto_rawDescOnce sync.Once
- file_fileTransfer_ftMessages_proto_rawDescData = file_fileTransfer_ftMessages_proto_rawDesc
-)
-
-func file_fileTransfer_ftMessages_proto_rawDescGZIP() []byte {
- file_fileTransfer_ftMessages_proto_rawDescOnce.Do(func() {
- file_fileTransfer_ftMessages_proto_rawDescData = protoimpl.X.CompressGZIP(file_fileTransfer_ftMessages_proto_rawDescData)
- })
- return file_fileTransfer_ftMessages_proto_rawDescData
-}
-
-var file_fileTransfer_ftMessages_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
-var file_fileTransfer_ftMessages_proto_goTypes = []interface{}{
- (*NewFileTransfer)(nil), // 0: parse.NewFileTransfer
-}
-var file_fileTransfer_ftMessages_proto_depIdxs = []int32{
- 0, // [0:0] is the sub-list for method output_type
- 0, // [0:0] is the sub-list for method input_type
- 0, // [0:0] is the sub-list for extension type_name
- 0, // [0:0] is the sub-list for extension extendee
- 0, // [0:0] is the sub-list for field type_name
-}
-
-func init() { file_fileTransfer_ftMessages_proto_init() }
-func file_fileTransfer_ftMessages_proto_init() {
- if File_fileTransfer_ftMessages_proto != nil {
- return
- }
- if !protoimpl.UnsafeEnabled {
- file_fileTransfer_ftMessages_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*NewFileTransfer); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- }
- type x struct{}
- out := protoimpl.TypeBuilder{
- File: protoimpl.DescBuilder{
- GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
- RawDescriptor: file_fileTransfer_ftMessages_proto_rawDesc,
- NumEnums: 0,
- NumMessages: 1,
- NumExtensions: 0,
- NumServices: 0,
- },
- GoTypes: file_fileTransfer_ftMessages_proto_goTypes,
- DependencyIndexes: file_fileTransfer_ftMessages_proto_depIdxs,
- MessageInfos: file_fileTransfer_ftMessages_proto_msgTypes,
- }.Build()
- File_fileTransfer_ftMessages_proto = out.File
- file_fileTransfer_ftMessages_proto_rawDesc = nil
- file_fileTransfer_ftMessages_proto_goTypes = nil
- file_fileTransfer_ftMessages_proto_depIdxs = nil
+func init() {
+ proto.RegisterType((*NewFileTransfer)(nil), "parse.NewFileTransfer")
+}
+
+func init() { proto.RegisterFile("fileTransfer/ftMessages.proto", fileDescriptor_9d574f363dd34365) }
+
+var fileDescriptor_9d574f363dd34365 = []byte{
+ // 213 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x90, 0xbd, 0x4a, 0xc7, 0x30,
+ 0x14, 0xc5, 0xc9, 0xdf, 0x7e, 0x19, 0xab, 0x42, 0x70, 0xb8, 0x08, 0x42, 0x70, 0xca, 0xa4, 0x83,
+ 0x6f, 0xe0, 0xe0, 0x22, 0x2d, 0x12, 0x3a, 0xb9, 0xc5, 0x72, 0x2b, 0x05, 0xdb, 0x86, 0x9b, 0x68,
+ 0xa9, 0xef, 0xec, 0x3b, 0x48, 0xa3, 0xad, 0x71, 0xcb, 0xef, 0x9c, 0x93, 0x73, 0xe1, 0xf0, 0xab,
+ 0xae, 0x7f, 0xc3, 0x86, 0xcc, 0xe8, 0x3a, 0xa4, 0xdb, 0xce, 0x57, 0xe8, 0x9c, 0x79, 0x45, 0x77,
+ 0x63, 0x69, 0xf2, 0x93, 0x48, 0xad, 0x21, 0x87, 0xd7, 0x5f, 0x8c, 0x9f, 0xd7, 0x38, 0x3f, 0x44,
+ 0x59, 0x71, 0xc9, 0x8b, 0xf5, 0x6f, 0x6d, 0x06, 0x04, 0x26, 0x99, 0x3a, 0xd6, 0x3b, 0x6f, 0x5e,
+ 0xb3, 0x58, 0x84, 0xc3, 0x9f, 0xb7, 0xb2, 0x90, 0xfc, 0xc4, 0xff, 0x76, 0x3c, 0xe2, 0x02, 0x47,
+ 0x92, 0xa9, 0x52, 0xc7, 0x52, 0x9c, 0xa8, 0x4c, 0x0b, 0xc9, 0xff, 0x44, 0x65, 0xda, 0xb5, 0x7f,
+ 0x7c, 0x1f, 0x9e, 0x0c, 0x79, 0x07, 0xa9, 0x64, 0xea, 0x54, 0xef, 0x2c, 0x04, 0x4f, 0x5c, 0xff,
+ 0x89, 0x90, 0x05, 0x3d, 0xbc, 0xc5, 0x05, 0x4f, 0x09, 0x3d, 0x2d, 0x90, 0x4b, 0xa6, 0x0e, 0xfa,
+ 0x07, 0x04, 0xf0, 0xdc, 0x12, 0x7e, 0xf4, 0x38, 0x43, 0x11, 0x6e, 0x6c, 0x78, 0x7f, 0xf6, 0x5c,
+ 0xc6, 0xbb, 0xbc, 0x64, 0x61, 0x8d, 0xbb, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0xcd, 0x93, 0x73,
+ 0x01, 0x2e, 0x01, 0x00, 0x00,
}
diff --git a/fileTransfer/ftMessages.proto b/fileTransfer/ftMessages.proto
index 22b2235a451b54a56b994018cc5f97f8c738299a..80547f782b1bb38886c34bc13ed7cf7ebefa8449 100644
--- a/fileTransfer/ftMessages.proto
+++ b/fileTransfer/ftMessages.proto
@@ -1,24 +1,24 @@
-///////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-///////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+// Copyright © 2020 xx network SEZC //
+// //
+// Use of this source code is governed by a license that can be found in the //
+// LICENSE file //
+////////////////////////////////////////////////////////////////////////////////
syntax = "proto3";
package parse;
-option go_package = "fileTransfer/";
+option go_package = "fileTransfer";
// NewFileTransfer is transmitted first on the initialization of a file transfer
// to inform the receiver about the incoming file.
message NewFileTransfer {
- string fileName = 1; // Name of the file; max 48 characters
- string fileType = 2; // Type of file; max 8 characters
- bytes transferKey = 3; // 256 bit encryption key to identify the transfer
- bytes transferMac = 4; // 256 bit MAC of the entire file
+ string fileName = 1; // Name of the file
+ string fileType = 2; // String that indicates type of file
+ bytes transferKey = 3; // 256-bit encryption key
+ bytes transferMac = 4; // 256-bit MAC of the entire file
uint32 numParts = 5; // Number of file parts
- uint32 size = 6; // The size of the file; max of 250 kB
- float retry = 7; // Used to determine how many times to retry sending
- bytes preview = 8; // A preview of the file; max of 4 kB
+ uint32 size = 6; // The size of the file, in bytes
+ float retry = 7; // Determines how many times to retry sending
+ bytes preview = 8; // A preview of the file
}
\ No newline at end of file
diff --git a/fileTransfer/generateProto.sh b/fileTransfer/generateProto.sh
index fd7eea2f23c4a365dcf68948eaa617c783ad1285..45c407448f50766cccb1e8adfee2be839bbf4c4d 100644
--- a/fileTransfer/generateProto.sh
+++ b/fileTransfer/generateProto.sh
@@ -1,3 +1,10 @@
#!/bin/bash
+#///////////////////////////////////////////////////////////////////////////////
+#/ Copyright © 2020 xx network SEZC //
+#/ //
+#/ Use of this source code is governed by a license that can be found in the //
+#/ LICENSE file //
+#///////////////////////////////////////////////////////////////////////////////
+
protoc --go_out=paths=source_relative:. fileTransfer/ftMessages.proto
diff --git a/fileTransfer2/groupChat/processor.go b/fileTransfer/groupChat/processor.go
similarity index 100%
rename from fileTransfer2/groupChat/processor.go
rename to fileTransfer/groupChat/processor.go
diff --git a/fileTransfer2/groupChat/send.go b/fileTransfer/groupChat/send.go
similarity index 100%
rename from fileTransfer2/groupChat/send.go
rename to fileTransfer/groupChat/send.go
diff --git a/fileTransfer2/groupChat/utils_test.go b/fileTransfer/groupChat/utils_test.go
similarity index 100%
rename from fileTransfer2/groupChat/utils_test.go
rename to fileTransfer/groupChat/utils_test.go
diff --git a/fileTransfer2/groupChat/wrapper.go b/fileTransfer/groupChat/wrapper.go
similarity index 99%
rename from fileTransfer2/groupChat/wrapper.go
rename to fileTransfer/groupChat/wrapper.go
index 176e247bd900d0eb60b03e936c525e77f9ecc69d..19d0ca4daadad700a9f6ecb830840807f2883cee 100644
--- a/fileTransfer2/groupChat/wrapper.go
+++ b/fileTransfer/groupChat/wrapper.go
@@ -9,7 +9,7 @@ package groupChat
import (
"github.com/pkg/errors"
- ft "gitlab.com/elixxir/client/fileTransfer2"
+ ft "gitlab.com/elixxir/client/fileTransfer"
"gitlab.com/elixxir/client/groupChat"
ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
"gitlab.com/elixxir/crypto/group"
diff --git a/fileTransfer2/groupChat/wrapper_test.go b/fileTransfer/groupChat/wrapper_test.go
similarity index 99%
rename from fileTransfer2/groupChat/wrapper_test.go
rename to fileTransfer/groupChat/wrapper_test.go
index a1bb774bfddefb5d199e58bd4b05d7668188414a..698b0b973a3fee9ebc962a0f90ec4447c6edac0f 100644
--- a/fileTransfer2/groupChat/wrapper_test.go
+++ b/fileTransfer/groupChat/wrapper_test.go
@@ -9,7 +9,7 @@ package groupChat
import (
"bytes"
- ft "gitlab.com/elixxir/client/fileTransfer2"
+ ft "gitlab.com/elixxir/client/fileTransfer"
"gitlab.com/elixxir/client/groupChat"
"gitlab.com/elixxir/crypto/fastRNG"
ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
diff --git a/fileTransfer2/info.go b/fileTransfer/info.go
similarity index 99%
rename from fileTransfer2/info.go
rename to fileTransfer/info.go
index 35068b5349fbcdd21e6413aba5afd8832b570999..034acf5327c41540dd80c0b084cb9c84b83a9001 100644
--- a/fileTransfer2/info.go
+++ b/fileTransfer/info.go
@@ -5,7 +5,7 @@
// LICENSE file //
////////////////////////////////////////////////////////////////////////////////
-package fileTransfer2
+package fileTransfer
import (
"github.com/golang/protobuf/proto"
diff --git a/fileTransfer2/info_test.go b/fileTransfer/info_test.go
similarity index 98%
rename from fileTransfer2/info_test.go
rename to fileTransfer/info_test.go
index 5713698639d9e122370e8f86e9533fba6da9ea18..f388eef9d32f6d90ac3d110e2548b80a7752e546 100644
--- a/fileTransfer2/info_test.go
+++ b/fileTransfer/info_test.go
@@ -5,7 +5,7 @@
// LICENSE file //
////////////////////////////////////////////////////////////////////////////////
-package fileTransfer2
+package fileTransfer
import (
ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
diff --git a/fileTransfer/interface.go b/fileTransfer/interface.go
index d31dbb99be99f532fab1a7bc9b5edaf8cc0817e5..a0f3ed1b142254ab40070ea4b281a2fa1847bfd7 100644
--- a/fileTransfer/interface.go
+++ b/fileTransfer/interface.go
@@ -18,24 +18,31 @@ import (
// SentProgressCallback is a callback function that tracks the progress of
// sending a file.
type SentProgressCallback func(completed bool, arrived, total uint16,
- t FilePartTracker, err error)
+ st SentTransfer, t FilePartTracker, err error)
// ReceivedProgressCallback is a callback function that tracks the progress of
// receiving a file.
type ReceivedProgressCallback func(completed bool, received, total uint16,
- t FilePartTracker, err error)
+ rt ReceivedTransfer, t FilePartTracker, err error)
// ReceiveCallback is a callback function that notifies the receiver of an
// incoming file transfer.
type ReceiveCallback func(tid *ftCrypto.TransferID, fileName, fileType string,
sender *id.ID, size uint32, preview []byte)
+// SendNew handles the sending of the initial message informing the recipient
+// of the incoming file transfer parts. SendNew should block until the send
+// completes and return an error only on failed sends.
+type SendNew func(transferInfo []byte) error
+
// FileTransfer facilities the sending and receiving of large file transfers.
// It allows for progress tracking of both inbound and outbound transfers.
+// FileTransfer handles the sending of the file data; however, the caller is
+// responsible for communicating to the recipient of the incoming file transfer.
type FileTransfer interface {
- // StartProcesses starts the listening for new file transfer messages and
- // starts the sending threads that wait for transfers to send.
+ // StartProcesses starts the sending threads that wait for file transfers to
+ // send. Adheres to the xxdk.Service type.
StartProcesses() (stoppable.Stoppable, error)
// MaxFileNameLen returns the max number of bytes allowed for a file name.
@@ -52,10 +59,11 @@ type FileTransfer interface {
MaxPreviewSize() int
/* === Sending ========================================================== */
- /* The processes of sending a file involves three main steps:
- 1. Sending the file using Send
- 2. Receiving transfer progress
- 3. Closing a finished send using CloseSend
+ /* The processes of sending a file involves four main steps:
+ 1. Set up a method to send initial file transfer details using SendNew.
+ 2. Sending the file using Send and register a progress callback.
+ 3. Receiving transfer progress on the progress callback.
+ 4. Closing a finished send using CloseSend.
Once the file is sent, it is broken into individual, equal-length parts
and sent to the recipient. Every time one of these parts arrives, it is
@@ -73,15 +81,17 @@ type FileTransfer interface {
// Send initiates the sending of a file to the recipient and returns a
// transfer ID that uniquely identifies this file transfer.
+ //
// In-progress transfers are restored when closing and reopening; however, a
// SentProgressCallback must be registered again.
+ //
+ // recipient - ID of the receiver of the file transfer. The sender must
+ // have an E2E relationship with the recipient.
// fileName - Human-readable file name. Max length defined by
// MaxFileNameLen.
// fileType - Shorthand that identifies the type of file. Max length
// defined by MaxFileTypeLen.
// fileData - File contents. Max size defined by MaxFileSize.
- // recipient - ID of the receiver of the file transfer. The sender must
- // have an E2E relationship with the recipient.
// retry - The number of sending retries allowed on send failure (e.g.
// a retry of 2.0 with 6 parts means 12 total possible sends).
// preview - A preview of the file data (e.g. a thumbnail). Max size
@@ -91,9 +101,11 @@ type FileTransfer interface {
// update (or less if restricted by the period), or on fatal error.
// period - A progress callback will be limited from triggering only once
// per period.
- Send(fileName, fileType string, fileData []byte, recipient *id.ID,
+ // sendNew - Function that sends the file transfer information to the
+ // recipient.
+ Send(recipient *id.ID, fileName, fileType string, fileData []byte,
retry float32, preview []byte, progressCB SentProgressCallback,
- period time.Duration) (*ftCrypto.TransferID, error)
+ period time.Duration, sendNew SendNew) (*ftCrypto.TransferID, error)
// RegisterSentProgressCallback allows for the registration of a callback to
// track the progress of an individual sent file transfer.
@@ -120,10 +132,14 @@ type FileTransfer interface {
CloseSend(tid *ftCrypto.TransferID) error
/* === Receiving ======================================================== */
- /* The processes of receiving a file involves three main steps:
- 1. Receiving a new file transfer on ReceiveCallback
- 2. Receiving transfer progress
- 3. Receiving the complete file using Receive
+ /* The processes of receiving a file involves four main steps:
+ 1. Receiving a new file transfer through a channel set up by the
+ caller.
+ 2. Registering the file transfer and a progress callback with
+ HandleIncomingTransfer.
+ 3. Receiving transfer progress on the progress callback.
+ 4. Receiving the complete file using Receive once the callback says
+ the transfer is complete.
Once the file transfer manager has started, it will call the
ReceiveCallback for every new file transfer that is received. Once that
@@ -134,6 +150,27 @@ type FileTransfer interface {
full file can be retrieved using Receive.
*/
+ // HandleIncomingTransfer starts tracking the received file parts for the
+ // given payload that contains the file transfer information and returns a
+ // transfer ID that uniquely identifies this file transfer along with the
+ // transfer information
+ //
+ // This function should be called once for every new file received on the
+ // registered SendNew callback.
+ //
+ // In-progress transfers are restored when closing and reopening; however, a
+ // ReceivedProgressCallback must be registered again.
+ //
+ // payload - A marshalled payload container the file transfer information.
+ // progressCB - A callback that reports the progress of the file transfer.
+ // The callback is called once on initialization, on every progress
+ // update (or less if restricted by the period), or on fatal error.
+ // period - A progress callback will be limited from triggering only once
+ // per period.
+ HandleIncomingTransfer(transferInfo []byte,
+ progressCB ReceivedProgressCallback, period time.Duration) (
+ *ftCrypto.TransferID, *TransferInfo, error)
+
// RegisterReceivedProgressCallback allows for the registration of a
// callback to track the progress of an individual received file transfer.
// This should be done when a new transfer is received on the
@@ -162,6 +199,27 @@ type FileTransfer interface {
Receive(tid *ftCrypto.TransferID) ([]byte, error)
}
+// SentTransfer tracks the information and individual parts of a sent file
+// transfer.
+type SentTransfer interface {
+ Recipient() *id.ID
+ Transfer
+}
+
+// ReceivedTransfer tracks the information and individual parts of a received
+// file transfer.
+type ReceivedTransfer interface {
+ Transfer
+}
+
+// Transfer is the generic structure for a file transfer.
+type Transfer interface {
+ TransferID() *ftCrypto.TransferID
+ FileName() string
+ FileSize() uint32
+ NumParts() uint16
+}
+
// FilePartTracker tracks the status of each file part in a sent or received
// file transfer.
type FilePartTracker interface {
diff --git a/fileTransfer/listener.go b/fileTransfer/listener.go
deleted file mode 100644
index 23f4202489ab262516203a53c42514d411db6c66..0000000000000000000000000000000000000000
--- a/fileTransfer/listener.go
+++ /dev/null
@@ -1,93 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package fileTransfer
-
-import (
- "github.com/golang/protobuf/proto"
- jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/client/e2e/receive"
- "gitlab.com/elixxir/client/fileTransfer/store"
- ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
-)
-
-// Error messages.
-const (
- errProtoUnmarshal = "[FT] Failed to proto unmarshal new file transfer request: %+v"
- errNewRtTransferID = "[FT] Failed to generate transfer ID for new received file transfer: %+v"
- errAddNewRt = "[FT] Failed to add new file transfer %s (%q): %+v"
-)
-
-// Name of listener (used for debugging)
-const listenerName = "NewFileTransferListener"
-
-// fileTransferListener waits for new file transfer messages to get ready to
-// receive the file transfer parts. Adheres to the receive.Listener interface.
-type fileTransferListener struct {
- *manager
-}
-
-// Hear is called when a new file transfer is received. It creates a new
-// internal received file transfer and starts waiting to receive file part
-// messages.
-func (ftl *fileTransferListener) Hear(msg receive.Message) {
- // Unmarshal the request message
- newFT := &NewFileTransfer{}
- err := proto.Unmarshal(msg.Payload, newFT)
- if err != nil {
- jww.ERROR.Printf(errProtoUnmarshal, err)
- return
- }
- // Generate new transfer ID
- rng := ftl.rng.GetStream()
- tid, err := ftCrypto.NewTransferID(rng)
- if err != nil {
- jww.ERROR.Printf(errNewRtTransferID, err)
- return
- }
- rng.Close()
-
- key := ftCrypto.UnmarshalTransferKey(newFT.TransferKey)
- numParts := uint16(newFT.GetNumParts())
- numFps := calcNumberOfFingerprints(int(numParts), newFT.GetRetry())
-
- rt, err := ftl.received.AddTransfer(&key, &tid, newFT.GetFileName(),
- newFT.GetTransferMac(), numParts, numFps, newFT.GetSize())
- if err != nil {
- jww.ERROR.Printf(errAddNewRt, tid, newFT.GetFileName(), err)
- }
-
- ftl.addFingerprints(rt)
-
- // Call the reception callback
- go ftl.receiveCB(&tid, newFT.GetFileName(), newFT.GetFileType(), msg.Sender,
- newFT.GetSize(), newFT.GetPreview())
-}
-
-// addFingerprints adds all fingerprints for unreceived parts in the received
-// transfer.
-func (m *manager) addFingerprints(rt *store.ReceivedTransfer) {
- // Build processor for each file part and add its fingerprint to receive on
- for _, c := range rt.GetUnusedCyphers() {
- p := &processor{
- Cypher: c,
- ReceivedTransfer: rt,
- manager: m,
- }
-
- err := m.cmix.AddFingerprint(m.myID, c.GetFingerprint(), p)
- if err != nil {
- jww.ERROR.Printf("[FT] Failed to add fingerprint for transfer "+
- "%s: %+v", rt.TransferID(), err)
- }
- }
-}
-
-// Name returns a name used for debugging.
-func (ftl *fileTransferListener) Name() string {
- return listenerName
-}
diff --git a/fileTransfer/manager.go b/fileTransfer/manager.go
index 03701de6adccc62944952c695a3126b7b26ef830..9325a57639f68c3fc3fad8326eed504b203f7bcc 100644
--- a/fileTransfer/manager.go
+++ b/fileTransfer/manager.go
@@ -10,17 +10,15 @@ package fileTransfer
import (
"bytes"
"github.com/pkg/errors"
- "gitlab.com/elixxir/client/catalog"
+ jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/cmix"
"gitlab.com/elixxir/client/cmix/message"
- "gitlab.com/elixxir/client/e2e"
- "gitlab.com/elixxir/client/e2e/receive"
"gitlab.com/elixxir/client/fileTransfer/callbackTracker"
"gitlab.com/elixxir/client/fileTransfer/store"
"gitlab.com/elixxir/client/fileTransfer/store/fileMessage"
"gitlab.com/elixxir/client/stoppable"
"gitlab.com/elixxir/client/storage/versioned"
- e2eCrypto "gitlab.com/elixxir/crypto/e2e"
+ "gitlab.com/elixxir/crypto/cyclic"
"gitlab.com/elixxir/crypto/fastRNG"
ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
"gitlab.com/elixxir/primitives/format"
@@ -83,6 +81,7 @@ const (
errSendNetworkHealth = "cannot initiate file transfer of %q when network is not healthy."
errNewKey = "could not generate new transfer key: %+v"
errNewID = "could not generate new transfer ID: %+v"
+ errMarshalInfo = "could not marshal transfer info: %+v"
errSendNewMsg = "failed to send initial file transfer message: %+v"
errAddSentTransfer = "failed to add transfer: %+v"
@@ -91,6 +90,10 @@ const (
errDeleteSentTransfer = "could not delete sent transfer %s: %+v"
errRemoveSentTransfer = "could not remove transfer %s from list: %+v"
+ // manager.HandleIncomingTransfer
+ errNewRtTransferID = "failed to generate transfer ID for new received file transfer %q: %+v"
+ errAddNewRt = "failed to add new file transfer %s (%q): %+v"
+
// manager.Receive
errIncompleteFile = "cannot get incomplete file: missing %d of %d parts"
errDeleteReceivedTransfer = "could not delete received transfer %s: %+v"
@@ -106,9 +109,6 @@ type manager struct {
// Storage-backed structure for tracking received file transfers
received *store.Received
- // Callback that is called every time a new file transfer is received
- receiveCB ReceiveCallback
-
// Progress callback tracker
callbacks *callbackTracker.Manager
@@ -121,13 +121,15 @@ type manager struct {
// File transfer parameters
params Params
- myID *id.ID
- cmix Cmix
- e2e E2e
- kv *versioned.KV
- rng *fastRNG.StreamGenerator
+ myID *id.ID
+ cmix Cmix
+ cmixGroup *cyclic.Group
+ kv *versioned.KV
+ rng *fastRNG.StreamGenerator
}
+// Cmix interface matches a subset of the cmix.Client methods used by the
+// manager for easier testing.
type Cmix interface {
GetMaxMessageLength() int
SendMany(messages []cmix.TargetedCmixMessage, p cmix.CMIXParams) (id.Round,
@@ -135,26 +137,27 @@ type Cmix interface {
AddFingerprint(identity *id.ID, fingerprint format.Fingerprint,
mp message.Processor) error
DeleteFingerprint(identity *id.ID, fingerprint format.Fingerprint)
+ CheckInProgressMessages()
IsHealthy() bool
AddHealthCallback(f func(bool)) uint64
RemoveHealthCallback(uint64)
- GetRoundResults(timeout time.Duration, roundCallback cmix.RoundEventCallback,
- roundList ...id.Round) error
+ GetRoundResults(timeout time.Duration,
+ roundCallback cmix.RoundEventCallback, roundList ...id.Round) error
}
-type E2e interface {
- SendE2E(mt catalog.MessageType, recipient *id.ID, payload []byte,
- params e2e.Params) ([]id.Round, e2eCrypto.MessageID, time.Time, error)
- RegisterListener(senderID *id.ID, messageType catalog.MessageType,
- newListener receive.Listener) receive.ListenerID
+// Storage interface matches a subset of the storage.Session methods used by the
+// manager for easier testing.
+type Storage interface {
+ GetKV() *versioned.KV
+ GetCmixGroup() *cyclic.Group
}
// NewManager creates a new file transfer manager object. If sent or received
// transfers already existed, they are loaded from storage and queued to resume
// once manager.startProcesses is called.
-func NewManager(receiveCB ReceiveCallback, params Params, myID *id.ID,
- cmix Cmix, e2e E2e, kv *versioned.KV,
+func NewManager(params Params, myID *id.ID, cmix Cmix, storage Storage,
rng *fastRNG.StreamGenerator) (FileTransfer, error) {
+ kv := storage.GetKV()
// Create a new list of sent file transfers or load one if it exists
sent, unsentParts, err := store.NewOrLoadSent(kv)
@@ -172,14 +175,13 @@ func NewManager(receiveCB ReceiveCallback, params Params, myID *id.ID,
m := &manager{
sent: sent,
received: received,
- receiveCB: receiveCB,
callbacks: callbackTracker.NewManager(),
batchQueue: make(chan store.Part, batchQueueBuffLen),
sendQueue: make(chan []store.Part, sendQueueBuffLen),
params: params,
myID: myID,
cmix: cmix,
- e2e: e2e,
+ cmixGroup: storage.GetCmixGroup(),
kv: kv,
rng: rng,
}
@@ -199,10 +201,6 @@ func NewManager(receiveCB ReceiveCallback, params Params, myID *id.ID,
// StartProcesses starts the sending threads. Adheres to the xxdk.Service type.
func (m *manager) StartProcesses() (stoppable.Stoppable, error) {
- // Register listener to receive new file transfers
- m.e2e.RegisterListener(
- m.myID, catalog.NewFileTransfer, &fileTransferListener{m})
-
// Construct stoppables
multiStop := stoppable.NewMulti(workerPoolStoppable)
batchBuilderStop := stoppable.NewSingle(batchBuilderThreadStoppable)
@@ -243,9 +241,9 @@ func (m *manager) MaxPreviewSize() int {
// Send partitions the given file into cMix message sized chunks and sends them
// via cmix.SendMany.
-func (m *manager) Send(fileName, fileType string, fileData []byte,
- recipient *id.ID, retry float32, preview []byte,
- progressCB SentProgressCallback, period time.Duration) (
+func (m *manager) Send(recipient *id.ID, fileName, fileType string,
+ fileData []byte, retry float32, preview []byte,
+ progressCB SentProgressCallback, period time.Duration, sendNew SendNew) (
*ftCrypto.TransferID, error) {
// Return an error if the file name is too long
@@ -297,8 +295,13 @@ func (m *manager) Send(fileName, fileType string, fileData []byte,
fileSize := uint32(len(fileData))
// Send the initial file transfer message over E2E
- err = m.sendNewFileTransferMessage(recipient, fileName, fileType, &key, mac,
- numParts, fileSize, retry, preview)
+ info := &TransferInfo{
+ fileName, fileType, key, mac, numParts, fileSize, retry, preview}
+ transferInfo, err := info.Marshal()
+ if err != nil {
+ return nil, errors.Errorf(errMarshalInfo, err)
+ }
+ err = sendNew(transferInfo)
if err != nil {
return nil, errors.Errorf(errSendNewMsg, err)
}
@@ -307,7 +310,8 @@ func (m *manager) Send(fileName, fileType string, fileData []byte,
numFps := calcNumberOfFingerprints(len(parts), retry)
// Create new sent transfer
- st, err := m.sent.AddTransfer(recipient, &key, &tid, fileName, parts, numFps)
+ st, err := m.sent.AddTransfer(
+ recipient, &key, &tid, fileName, fileSize, parts, numFps)
if err != nil {
return nil, errors.Errorf(errAddSentTransfer, err)
}
@@ -351,16 +355,11 @@ func (m *manager) registerSentProgressCallback(st *store.SentTransfer,
arrived, total := st.NumArrived(), st.NumParts()
completed := arrived == total
- // If the transfer is completed, send last message informing recipient
- if completed {
- m.sendEndFileTransferMessage(st.Recipient())
- }
-
// Build part tracker from copy of part statuses vector
tracker := &sentFilePartTracker{st.CopyPartStatusVector()}
// Call the progress callback
- progressCB(completed, arrived, total, tracker, err)
+ progressCB(completed, arrived, total, st, tracker, err)
}
// Add the callback to the callback tracker
@@ -402,6 +401,49 @@ func (m *manager) CloseSend(tid *ftCrypto.TransferID) error {
/* === Receiving ============================================================ */
+const errUnmarshalInfo = "failed to unmarshal incoming transfer info: %+v"
+
+// HandleIncomingTransfer starts tracking the received file parts for the given
+// file information and returns a transfer ID that uniquely identifies this file
+// transfer.
+func (m *manager) HandleIncomingTransfer(transferInfo []byte,
+ progressCB ReceivedProgressCallback, period time.Duration) (
+ *ftCrypto.TransferID, *TransferInfo, error) {
+
+ // Unmarshal the payload
+ t, err := UnmarshalTransferInfo(transferInfo)
+ if err != nil {
+ return nil, nil, errors.Errorf(errUnmarshalInfo, err)
+ }
+
+ // Generate new transfer ID
+ rng := m.rng.GetStream()
+ tid, err := ftCrypto.NewTransferID(rng)
+ if err != nil {
+ rng.Close()
+ return nil, nil, errors.Errorf(errNewRtTransferID, t.FileName, err)
+ }
+ rng.Close()
+
+ // Calculate the number of fingerprints based on the retry rate
+ numFps := calcNumberOfFingerprints(int(t.NumParts), t.Retry)
+
+ // Store the transfer
+ rt, err := m.received.AddTransfer(
+ &t.Key, &tid, t.FileName, t.Mac, t.Size, t.NumParts, numFps)
+ if err != nil {
+ return nil, nil, errors.Errorf(errAddNewRt, tid, t.FileName, err)
+ }
+
+ // Start tracking fingerprints for each file part
+ m.addFingerprints(rt)
+
+ // Register the progress callback
+ m.registerReceivedProgressCallback(rt, progressCB, period)
+
+ return &tid, t, nil
+}
+
// Receive concatenates the received file and returns it. Only returns the file
// if all file parts have been received and returns an error otherwise. Also
// deletes the transfer from storage. Once Receive has been called on a file, it
@@ -477,7 +519,7 @@ func (m *manager) registerReceivedProgressCallback(rt *store.ReceivedTransfer,
tracker := &receivedFilePartTracker{rt.CopyPartStatusVector()}
// Call the progress callback
- progressCB(completed, received, total, tracker, err)
+ progressCB(completed, received, total, rt, tracker, err)
}
// Add the callback to the callback tracker
@@ -508,3 +550,24 @@ func partitionFile(file []byte, partSize int) [][]byte {
func calcNumberOfFingerprints(numParts int, retry float32) uint16 {
return uint16(float32(numParts) * (1 + retry))
}
+
+// addFingerprints adds all fingerprints for unreceived parts in the received
+// transfer.
+func (m *manager) addFingerprints(rt *store.ReceivedTransfer) {
+ // Build processor for each file part and add its fingerprint to receive on
+ for _, c := range rt.GetUnusedCyphers() {
+ p := &processor{
+ Cypher: c,
+ ReceivedTransfer: rt,
+ manager: m,
+ }
+
+ err := m.cmix.AddFingerprint(m.myID, c.GetFingerprint(), p)
+ if err != nil {
+ jww.ERROR.Printf("[FT] Failed to add fingerprint for transfer "+
+ "%s: %+v", rt.TransferID(), err)
+ }
+ }
+
+ m.cmix.CheckInProgressMessages()
+}
diff --git a/fileTransfer/manager_test.go b/fileTransfer/manager_test.go
index 7245028f3b15f5ceff44bcfa2e527ec3c10088a9..ca30656754379722516dee3068559b2b2086b4d2 100644
--- a/fileTransfer/manager_test.go
+++ b/fileTransfer/manager_test.go
@@ -9,26 +9,29 @@ package fileTransfer
import (
"bytes"
- "gitlab.com/elixxir/client/catalog"
- "gitlab.com/elixxir/client/e2e/receive"
- "gitlab.com/elixxir/client/storage/versioned"
+ "gitlab.com/elixxir/client/cmix"
+ "gitlab.com/elixxir/client/storage"
"gitlab.com/elixxir/crypto/fastRNG"
- ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
- "gitlab.com/elixxir/ekv"
"gitlab.com/xx_network/crypto/csprng"
"gitlab.com/xx_network/primitives/id"
"gitlab.com/xx_network/primitives/netTime"
+ "math"
"math/rand"
"reflect"
"sync"
+ "sync/atomic"
"testing"
"time"
)
// Tests that manager adheres to the FileTransfer interface.
-func Test_manager_FileTransferInterface(t *testing.T) {
- var _ FileTransfer = (*manager)(nil)
-}
+var _ FileTransfer = (*manager)(nil)
+
+// Tests that Cmix adheres to the cmix.Client interface.
+var _ Cmix = (cmix.Client)(nil)
+
+// Tests that Storage adheres to the storage.Session interface.
+var _ Storage = (storage.Session)(nil)
// Tests that partitionFile partitions the given file into the expected parts.
func Test_partitionFile(t *testing.T) {
@@ -77,36 +80,19 @@ func Test_calcNumberOfFingerprints(t *testing.T) {
// Smoke test of the entire file transfer system.
func Test_FileTransfer_Smoke(t *testing.T) {
+ // jww.SetStdoutThreshold(jww.LevelDebug)
// Set up cMix and E2E message handlers
cMixHandler := newMockCmixHandler()
- e2eHandler := newMockE2eHandler()
rngGen := fastRNG.NewStreamGenerator(1000, 10, csprng.NewSystemRNG)
params := DefaultParams()
-
- type receiveCbValues struct {
- tid *ftCrypto.TransferID
- fileName string
- fileType string
- sender *id.ID
- size uint32
- preview []byte
- }
+ // params.MaxThroughput = math.MaxInt
+ // params.MaxThroughput = 0
// Set up the first client
- receiveCbChan1 := make(chan receiveCbValues, 10)
- receiveCB1 := func(tid *ftCrypto.TransferID, fileName, fileType string,
- sender *id.ID, size uint32, preview []byte) {
- receiveCbChan1 <- receiveCbValues{
- tid, fileName, fileType, sender, size, preview}
- }
myID1 := id.NewIdFromString("myID1", id.User, t)
- kv1 := versioned.NewKV(ekv.MakeMemstore())
- endE2eChan1 := make(chan receive.Message, 3)
- e2e1 := newMockE2e(myID1, e2eHandler)
- e2e1.RegisterListener(
- myID1, catalog.EndFileTransfer, newMockListener(endE2eChan1))
- ftm1, err := NewManager(receiveCB1, params, myID1,
- newMockCmix(myID1, cMixHandler), e2e1, kv1, rngGen)
+ storage1 := newMockStorage()
+ ftm1, err := NewManager(params, myID1,
+ newMockCmix(myID1, cMixHandler, storage1), storage1, rngGen)
if err != nil {
t.Errorf("Failed to create new file transfer manager 1: %+v", err)
}
@@ -118,20 +104,10 @@ func Test_FileTransfer_Smoke(t *testing.T) {
}
// Set up the second client
- receiveCbChan2 := make(chan receiveCbValues, 10)
- receiveCB2 := func(tid *ftCrypto.TransferID, fileName, fileType string,
- sender *id.ID, size uint32, preview []byte) {
- receiveCbChan2 <- receiveCbValues{
- tid, fileName, fileType, sender, size, preview}
- }
myID2 := id.NewIdFromString("myID2", id.User, t)
- kv2 := versioned.NewKV(ekv.MakeMemstore())
- endE2eChan2 := make(chan receive.Message, 3)
- e2e2 := newMockE2e(myID1, e2eHandler)
- e2e2.RegisterListener(
- myID2, catalog.EndFileTransfer, newMockListener(endE2eChan2))
- ftm2, err := NewManager(receiveCB2, params, myID2,
- newMockCmix(myID2, cMixHandler), e2e2, kv2, rngGen)
+ storage2 := newMockStorage()
+ ftm2, err := NewManager(params, myID2,
+ newMockCmix(myID2, cMixHandler, storage2), storage2, rngGen)
if err != nil {
t.Errorf("Failed to create new file transfer manager 2: %+v", err)
}
@@ -142,13 +118,19 @@ func Test_FileTransfer_Smoke(t *testing.T) {
t.Errorf("Failed to start processes for manager 2: %+v", err)
}
+ sendNewCbChan1 := make(chan []byte)
+ sendNewCb1 := func(transferInfo []byte) error {
+ sendNewCbChan1 <- transferInfo
+ return nil
+ }
+
// Wait group prevents the test from quiting before the file has completed
// sending and receiving
var wg sync.WaitGroup
// Define details of file to send
fileName, fileType := "myFile", "txt"
- fileData := []byte(loreumIpsum)
+ fileData := []byte(loremIpsum)
preview := []byte("Lorem ipsum dolor sit amet")
retry := float32(2.0)
@@ -156,16 +138,20 @@ func Test_FileTransfer_Smoke(t *testing.T) {
// a progress callback that then checks that the file received is correct
// when done
wg.Add(1)
- var called bool
+ called := uint32(0)
timeReceived := make(chan time.Time)
go func() {
select {
- case r := <-receiveCbChan2:
+ case r := <-sendNewCbChan1:
+ tid, _, err := m2.HandleIncomingTransfer(r, nil, 0)
+ if err != nil {
+ t.Errorf("Failed to add transfer: %+v", err)
+ }
receiveProgressCB := func(completed bool, received, total uint16,
- fpt FilePartTracker, err error) {
- if completed && !called {
+ rt ReceivedTransfer, fpt FilePartTracker, err error) {
+ if completed && atomic.CompareAndSwapUint32(&called, 0, 1) {
timeReceived <- netTime.Now()
- receivedFile, err2 := m2.Receive(r.tid)
+ receivedFile, err2 := m2.Receive(tid)
if err2 != nil {
t.Errorf("Failed to receive file: %+v", err2)
}
@@ -179,7 +165,7 @@ func Test_FileTransfer_Smoke(t *testing.T) {
}
}
err3 := m2.RegisterReceivedProgressCallback(
- r.tid, receiveProgressCB, 0)
+ tid, receiveProgressCB, 0)
if err3 != nil {
t.Errorf(
"Failed to Rregister received progress callback: %+v", err3)
@@ -193,7 +179,7 @@ func Test_FileTransfer_Smoke(t *testing.T) {
// Define sent progress callback
wg.Add(1)
sentProgressCb1 := func(completed bool, arrived, total uint16,
- fpt FilePartTracker, err error) {
+ st SentTransfer, fpt FilePartTracker, err error) {
if completed {
wg.Done()
}
@@ -201,8 +187,8 @@ func Test_FileTransfer_Smoke(t *testing.T) {
// Send file.
sendStart := netTime.Now()
- tid1, err := m1.Send(
- fileName, fileType, fileData, myID2, retry, preview, sentProgressCb1, 0)
+ tid1, err := m1.Send(myID2, fileName, fileType, fileData, retry, preview,
+ sentProgressCb1, 0, sendNewCb1)
if err != nil {
t.Errorf("Failed to send file: %+v", err)
}
@@ -212,10 +198,15 @@ func Test_FileTransfer_Smoke(t *testing.T) {
case tr := <-timeReceived:
fileSize := len(fileData)
sendTime := tr.Sub(sendStart)
- fileSizeKb := float32(fileSize) * .001
- speed := fileSizeKb * float32(time.Second) / (float32(sendTime))
- t.Logf("Completed sending file %q in %s (%.2f kb @ %.2f kb/s).",
- fileName, sendTime, fileSizeKb, speed)
+ fileSizeKb := float64(fileSize) * .001
+ throughput := fileSizeKb * float64(time.Second) / (float64(sendTime))
+ t.Logf("Completed receiving file %q in %s (%.2f kb @ %.2f kb/s).",
+ fileName, sendTime, fileSizeKb, throughput)
+
+ expectedThroughput := float64(params.MaxThroughput) * .001
+ delta := (math.Abs(expectedThroughput-throughput) / ((expectedThroughput + throughput) / 2)) * 100
+ t.Logf("Expected bandwidth: %.2f kb/s", expectedThroughput)
+ t.Logf("Bandwidth difference: %.2f kb/s (%.2f%%)", expectedThroughput-throughput, delta)
}
}()
@@ -238,12 +229,336 @@ func Test_FileTransfer_Smoke(t *testing.T) {
}
}
-const loreumIpsum = `Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed sit amet urna venenatis, rutrum magna maximus, tempor orci. Cras sit amet nulla id dolor blandit commodo. Suspendisse potenti. Praesent gravida porttitor metus vel aliquam. Maecenas rutrum velit at lobortis auctor. Mauris porta blandit tempor. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Morbi volutpat posuere maximus. Nunc in augue molestie ante mattis tempor.
+const loremIpsum = `Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut at efficitur urna, et ultrices leo. Sed lacinia vestibulum tortor eu convallis. Proin imperdiet accumsan magna, sed volutpat tortor consectetur at. Mauris sed dolor sed sapien porta consectetur in eu sem. Maecenas vestibulum varius erat, eget porta eros vehicula mattis. Phasellus tempor odio at tortor maximus convallis. Nullam ut lorem laoreet, tincidunt ex sollicitudin, aliquam urna. Mauris vel enim consequat, sodales nibh quis, sollicitudin ipsum. Quisque lacinia, sapien a tempor eleifend, dolor nibh posuere neque, sit amet tempus dolor ante non nunc. Proin tempor blandit mollis. Mauris nunc sem, egestas eget velit ut, luctus molestie ipsum. Pellentesque sed eleifend dolor. Nullam pulvinar dignissim ante, eget luctus quam hendrerit vel. Proin ornare non tortor vitae rhoncus. Etiam tellus sem, condimentum id bibendum sed, blandit ac lorem. Maecenas gravida, neque quis blandit ultrices, nisl elit pretium nulla, ac volutpat massa odio sed arcu.
+
+Etiam at nibh dui. Vestibulum eget odio vestibulum sapien volutpat facilisis. Phasellus tempor risus in nisi viverra, ut porta est dictum. Aliquam in urna gravida, pulvinar sem ac, luctus erat. Fusce posuere id mauris non placerat. Quisque porttitor sagittis sapien nec scelerisque. Aenean sed mi nec ante tincidunt maximus. Etiam accumsan, dui eget varius mattis, ex quam efficitur est, id ornare nulla orci id mi. Mauris vulputate tincidunt nunc, et tempor augue sollicitudin eget.
+
+Sed vitae commodo neque, euismod finibus libero. Integer eget condimentum elit, id volutpat odio. Donec convallis magna lacus, varius volutpat augue lacinia a. Proin venenatis ex et ullamcorper faucibus. Nulla scelerisque, mauris id molestie hendrerit, magna justo faucibus lacus, quis convallis nulla lorem nec nisi. Nunc dictum nisi a molestie efficitur. Etiam vel nibh sit amet nibh finibus gravida eget id tellus. Donec elementum blandit molestie. Donec fringilla sapien ut neque bibendum, at ultrices dui molestie. Sed lobortis auctor justo at tincidunt. In vitae velit augue. Vestibulum pharetra ex quam, in vehicula urna ullamcorper sit amet. Phasellus at rhoncus diam, nec interdum ligula. Pellentesque eget risus dictum, ultrices velit at, fermentum justo. Nulla orci ex, tempor vitae velit eu, gravida pellentesque dolor.
+
+Aenean auctor at lorem in auctor. Sed at mi non quam aliquam aliquet vitae eu erat. Sed eu orci ac elit scelerisque rhoncus eget at orci. Donec a imperdiet ipsum. Phasellus efficitur lobortis mauris, et scelerisque diam consectetur sit amet. Nunc nunc lectus, accumsan vel eleifend vel, tempor vitae sapien. Nunc dictum tempus turpis non blandit. Sed condimentum pretium velit ac sodales. In accumsan leo vel sem commodo, eget hendrerit risus interdum. Nullam quis malesuada purus, non euismod turpis. In augue lorem, convallis quis urna vel, euismod tincidunt nunc. Ut eget luctus lacus, in commodo diam.
+
+Aenean ut ante sed ex ornare maximus quis venenatis urna. Fusce commodo fermentum velit nec varius. Etiam vitae odio vel nisl condimentum fringilla. Donec in risus tincidunt ex placerat vestibulum. Donec hendrerit tellus convallis malesuada vulputate. Aenean condimentum metus id est mollis viverra. Quisque at auctor turpis. Aenean est metus, laoreet eu justo a, consequat suscipit nibh. Etiam mattis massa in sem sollicitudin, non blandit dolor pharetra. Vivamus pretium nunc ut lacus interdum, ut feugiat lectus blandit. Vestibulum sit amet scelerisque lectus. Nam ut lorem mattis urna semper rutrum.
+
+Maecenas imperdiet libero et metus porta maximus. Duis lobortis porttitor sem, ut dictum urna consequat vitae. Sed consectetur est at arcu fringilla scelerisque. Nulla finibus libero eu nibh vulputate euismod. Praesent volutpat nisi eget elit dignissim, ac imperdiet nisi mollis. Integer a venenatis neque. Fusce leo leo, auctor sit amet auctor in, elementum quis magna.
+
+Donec efficitur ullamcorper ex eget pretium. Suspendisse pharetra sagittis neque, eget laoreet sem maximus et. Etiam sit amet mi ut purus ornare molestie a nec diam. Sed eleifend dui at orci sollicitudin bibendum. Mauris non leo eu est consequat porttitor consectetur vel massa. Nullam pretium molestie leo in hendrerit. Etiam dapibus ante tellus, quis hendrerit turpis feugiat vitae. Maecenas id lorem quis nibh tincidunt accumsan sed sed nisi. Duis non faucibus odio. Fusce porta enim vitae ex ultrices, non euismod nibh posuere.
+
+Suspendisse luctus orci blandit, tempor ipsum in, molestie erat. Fusce commodo sed sapien quis interdum. Etiam sollicitudin ipsum a ipsum tempus, a vestibulum ligula hendrerit. Integer eget nisl a arcu hendrerit sollicitudin. Fusce a purus ornare, sollicitudin ante in, gravida elit. Vestibulum ut tortor volutpat, sodales enim eget, aliquam risus. Pellentesque efficitur nec sem id molestie. Mauris molestie, risus sit amet dignissim dictum, turpis ante vehicula tellus, in eleifend risus metus in mi. Aenean interdum ac metus ac porttitor. Vivamus nec blandit arcu. Maecenas fringilla varius metus, sed viverra diam facilisis a.
+
+Curabitur placerat cursus sem, in laoreet elit mollis in. Nam convallis aliquam placerat. Sed quis efficitur est. Proin id massa quam. Fusce nec porttitor quam. Nunc ac massa imperdiet, pretium nibh quis, maximus nisi. Interdum et malesuada fames ac ante ipsum primis in faucibus. Donec pretium purus id viverra fringilla. Cras congue facilisis orci et ullamcorper. In ac turpis arcu. Praesent convallis in ligula vitae suscipit.
+
+Etiam et egestas ipsum, ac lacinia erat. Nunc in metus sit amet lectus ultricies viverra in sed elit. Ut euismod urna eget nisl faucibus, accumsan vestibulum dolor suscipit. Aenean a volutpat ipsum. Nulla pharetra enim eu lorem vestibulum malesuada. Nulla facilisi. In congue at odio vel imperdiet. Fusce in elit in nibh dapibus rutrum. Donec consequat mauris a sem viverra egestas. Suspendisse sollicitudin dapibus finibus. Nullam tempus et lacus sed feugiat. Suspendisse aliquet, sem a fringilla elementum, ante lorem elementum odio, quis sollicitudin magna nibh sed libero. Maecenas convallis congue neque, ut molestie nibh porttitor ac. Vestibulum quis justo sed ipsum tempus viverra. Quisque mauris erat, varius a ipsum eu, porta molestie odio. Morbi mauris ante, sagittis eget nibh vel, volutpat faucibus nunc.
+
+Donec id neque feugiat, tristique neque et, luctus nibh. Duis vel lacus eu nisl dignissim sagittis sed sed lacus. Praesent luctus eleifend aliquet. Sed tempus facilisis lorem, sit amet tristique metus suscipit ac. Vestibulum id sapien ac erat luctus fermentum venenatis sit amet erat. Maecenas posuere finibus mi. Phasellus facilisis efficitur turpis sed auctor. Nullam lobortis ornare velit ac scelerisque. Vestibulum facilisis, odio ac finibus viverra, leo leo sodales arcu, sed ornare ex ligula vel lacus. Nullam odio orci, pulvinar eu urna in, tristique ornare augue.
+
+Vivamus scelerisque egestas justo, at dignissim erat elementum id. Etiam vel suscipit erat. Nulla accumsan ex sem, id pharetra eros tincidunt sodales. Nullam enim augue, interdum ut est ac, faucibus semper justo. Aliquam ut iaculis magna. Sed magna turpis, pretium nec lobortis vel, facilisis vitae mauris. Donec tincidunt eros in mauris maximus porta id vehicula mi. Integer ut orci lobortis turpis vehicula viverra. Vestibulum at blandit nunc, ac pretium quam. Morbi ac metus placerat, congue lorem nec, pharetra neque.
+
+Sed vestibulum nibh ex, fringilla lobortis libero sodales sed. Aenean vehicula nibh tellus, egestas eleifend diam sollicitudin non. Fusce ut sollicitudin leo. Nam tempor dictum erat sit amet vestibulum. Pellentesque ornare mattis ex, nec malesuada elit sollicitudin vitae. Nulla nec semper enim, venenatis ornare orci. Aliquam urna purus, ornare eu ipsum vitae, consectetur faucibus elit. Nulla vestibulum semper ligula, id rhoncus tortor accumsan nec. Vestibulum non ante sed urna efficitur imperdiet vitae quis felis. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque rutrum quam sit amet nisl facilisis, quis maximus ante bibendum.
+
+Integer vel tortor nec est sodales posuere ut ac ipsum. Curabitur id odio nisl. Sed id augue iaculis, viverra risus nec, bibendum nunc. Cras ex risus, semper ac lorem nec, mattis dictum purus. Aenean semper et lacus at condimentum. Fusce nisl dolor, facilisis nec velit at, tempus pharetra mauris. Nam ac magna urna. Nulla convallis libero sed ex eleifend, ac molestie magna rhoncus.
+
+Donec blandit aliquam metus molestie suscipit. Cras et malesuada urna, non facilisis turpis. Donec non orci at leo aliquet porttitor vel non turpis. Nam consequat libero quam, non egestas ipsum eleifend quis. Mauris laoreet tellus enim, ac porta sapien condimentum quis. Nunc non sagittis orci. Aenean leo nibh, feugiat in turpis eget, hendrerit faucibus ligula. Morbi et massa nulla. Curabitur ac tempus nibh. Quisque commodo imperdiet viverra. Quisque sit amet condimentum mauris.
+
+Aliquam vel velit sed turpis consectetur eleifend quis et quam. Integer sed magna vel nisl consectetur lacinia vitae et ante. Duis consequat nulla ac leo auctor, ac euismod ipsum semper. Aliquam libero neque, imperdiet et nisi fringilla, vehicula elementum leo. Phasellus facilisis felis nec sagittis sodales. Donec ac consectetur odio. Aliquam eu aliquam lacus. Aliquam dictum eleifend risus, hendrerit eleifend nibh feugiat at. Aenean id tristique justo. Maecenas vel nibh quis massa aliquam convallis in eget mauris.
+
+Vestibulum nec fringilla neque, sit amet pellentesque dolor. Aenean a dolor enim. Morbi urna orci, mollis in viverra vel, volutpat vitae magna. Aenean sodales nec nisi ultrices condimentum. Quisque in turpis lobortis purus elementum maximus lacinia et nibh. Donec sed tortor eu nibh bibendum convallis in quis massa. Integer efficitur ultricies odio vel commodo.
+
+Quisque fermentum odio sit amet nunc tempus, vel porta nunc lobortis. Nam pellentesque elit non leo interdum, blandit eleifend purus suscipit. Nullam porta est non enim vulputate, ut molestie tortor ullamcorper. Donec fermentum, lectus suscipit commodo aliquet, tellus lacus rutrum ante, quis condimentum risus nisi id risus. Ut dapibus hendrerit odio non aliquet. Integer neque odio, dictum ac efficitur sit amet, facilisis a lacus. Nulla placerat erat et tortor placerat, vel posuere felis dignissim. Morbi non scelerisque ipsum. Aliquam hendrerit vestibulum metus vel pellentesque. Nunc fringilla turpis sodales nisi vestibulum faucibus. Quisque vehicula est arcu, tempus eleifend lorem scelerisque vitae.
+
+Nullam vehicula tortor vel purus hendrerit convallis. Cras sagittis metus ex, sit amet sollicitudin lectus vulputate quis. Integer sem odio, lobortis et pretium non, pharetra ut lorem. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Pellentesque aliquam aliquet lorem, faucibus venenatis diam viverra in. Nullam pulvinar, nisi vel elementum venenatis, lacus risus convallis neque, ac eleifend lorem enim ac turpis. Pellentesque tellus quam, dictum eu nisl non, cursus pellentesque justo.
+
+Cras pharetra lorem sed magna vulputate, eget iaculis elit molestie. Morbi a est finibus, condimentum nunc at, feugiat magna. Curabitur turpis turpis, placerat sed risus vitae, porta volutpat elit. Phasellus id neque diam. Maecenas eu metus a urna iaculis egestas eget at elit. Nunc vehicula molestie dapibus. In auctor sapien eget mi tempus, eu tempor massa egestas. Pellentesque metus sem, pharetra non urna ac, convallis hendrerit massa. Mauris nunc velit, maximus sit amet est sit amet, gravida ultrices elit. Vivamus ut luctus nisl. Nam et ultrices ipsum. Maecenas eget blandit mi. Curabitur eu lorem nec est vehicula sodales.
+
+Vestibulum hendrerit sed est vitae egestas. Nam molestie, augue non consequat efficitur, elit purus commodo orci, et pharetra ante risus eget augue. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Maecenas a nulla enim. Ut accumsan sodales ultrices. Quisque gravida, leo rhoncus placerat egestas, eros felis posuere diam, ut eleifend orci nisl vitae lorem. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Etiam sit amet urna venenatis, pulvinar nisi eget, tristique nisi. Nam nec purus hendrerit, congue augue et, facilisis diam. Donec aliquet eleifend mauris. Vivamus eu libero rhoncus, scelerisque metus at, hendrerit quam. Cras vulputate, magna eget pretium accumsan, tortor nunc molestie quam, at vulputate turpis velit eget arcu. Etiam tristique sollicitudin est, in condimentum diam faucibus vitae.
+
+Curabitur id lorem elementum diam sollicitudin gravida a sit amet ipsum. Pellentesque tortor ligula, auctor at ultricies non, pulvinar et risus. Ut vitae cursus metus. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Sed quis tortor feugiat, fermentum nunc at, sodales massa. Donec efficitur euismod diam non sodales. In eu augue quis enim elementum auctor. In hac habitasse platea dictumst. Cras in libero nec urna tempor venenatis vitae a diam. Nam vulputate nisl nulla, ut porttitor elit euismod non. Praesent eget tempus lacus, vel ullamcorper nulla. Quisque ut risus nibh. Nam rhoncus commodo consectetur. Sed ultrices sapien id lectus imperdiet, sed tincidunt est dapibus.
+
+Integer posuere mattis ipsum congue ullamcorper. Nunc ac vulputate magna. Ut bibendum scelerisque lectus. Nullam laoreet porta nunc, in viverra dolor blandit eu. Ut semper id urna quis bibendum. Vivamus sed felis nec sapien faucibus volutpat sed et nisi. Morbi faucibus venenatis imperdiet. Mauris semper ex ac blandit scelerisque. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas.
+
+Suspendisse vitae lectus diam. Nulla vel lectus non magna congue pharetra eget nec augue. Morbi elementum, nisl ut vestibulum varius, quam sapien convallis magna, tempus maximus nunc est vel purus. In molestie ligula sed placerat sagittis. In rutrum, felis volutpat pulvinar pharetra, arcu odio egestas augue, ut dapibus leo libero nec urna. Curabitur tortor sapien, aliquam id suscipit et, feugiat a leo. Sed mollis imperdiet tellus, ac placerat felis tristique sed. Fusce pulvinar est felis, sed rutrum neque sollicitudin sit amet. Donec tincidunt elit vel felis sagittis, sit amet vestibulum enim pellentesque. Nam accumsan rhoncus tellus vitae auctor.
+
+Praesent mattis risus eget dui finibus lobortis. Suspendisse auctor commodo viverra. Quisque a ante ante. Proin magna mi, efficitur vitae arcu vel, vehicula viverra lacus. Nulla rhoncus aliquet tortor eget iaculis. Vestibulum ac mollis risus. Curabitur non rhoncus neque. Donec non ipsum quis lectus fermentum convallis ac quis risus.
+
+Pellentesque aliquam diam diam, in tempus nisi rhoncus sed. Praesent ultricies nisl justo, sit amet suscipit lectus pharetra quis. Praesent non diam in dolor vulputate molestie ut vel nulla. Cras vel congue neque, in ultricies metus. Aliquam ultricies quam eget placerat accumsan. Aenean sodales cursus semper. Donec justo ex, euismod et mollis at, congue a arcu.
+
+In at sapien pulvinar, scelerisque felis sit amet, hendrerit diam. Aliquam pellentesque est vel augue dignissim, quis ornare sapien tincidunt. Nullam porta tincidunt tempus. Morbi eget arcu sed mauris tincidunt malesuada. Vivamus eleifend tortor in diam vulputate, non convallis nisi sodales. Vestibulum id arcu quis nisl maximus semper. Nunc quis dui vitae lectus dapibus luctus. Mauris mattis convallis mi, ut fringilla velit pulvinar non.
+
+Nam auctor ligula id dignissim pretium. Aliquam id ultricies massa. Suspendisse ullamcorper nec enim non egestas. Sed tristique, est eu cursus elementum, mauris nisi consectetur nulla, dapibus ultricies tortor mi ut augue. Sed vitae velit luctus, viverra velit a, malesuada eros. Mauris efficitur tortor quam, sed sodales velit suscipit varius. Integer varius nisi sit amet pharetra consequat. Fusce a fringilla felis, vel porta risus. Maecenas nibh magna, euismod quis tellus nec, faucibus mattis erat. Nulla facilisi. Cras maximus tempor dolor, a tristique diam consectetur in. Nam semper sapien tincidunt justo ornare vehicula. Suspendisse sit amet egestas lacus, ac bibendum urna.
+
+Integer sed est id tortor molestie placerat. Pellentesque vehicula risus eget massa lacinia hendrerit. Sed ut elit quis diam posuere bibendum in et ligula. Donec lobortis lacus eget aliquet maximus. Nullam risus massa, imperdiet eu urna ut, luctus fringilla tortor. Ut imperdiet nibh metus. Sed vitae purus nisl.
+
+Nunc sed magna arcu. Proin ornare lectus at semper hendrerit. Donec mi nunc, mattis in nibh a, facilisis ornare arcu. Curabitur in pretium turpis. Donec vulputate turpis sem, quis consectetur felis euismod a. Nullam sapien libero, dictum a odio a, pretium accumsan mauris. Nunc et velit varius, gravida metus non, mollis dui. Praesent nec dictum lorem, id bibendum nisi. In hac habitasse platea dictumst. Curabitur in imperdiet eros. Quisque vitae turpis lorem. In hac habitasse platea dictumst. Aliquam lobortis felis sit amet metus maximus, sit amet vulputate lorem ornare. In non ultrices eros.
+
+Praesent tellus nisl, feugiat ut rhoncus at, euismod ac ipsum. Donec vitae felis consectetur dolor ultricies scelerisque et at mauris. Donec justo lorem, euismod non velit ac, malesuada tempus sem. Pellentesque nunc sem, pharetra sed fermentum non, dignissim at nunc. Sed placerat dignissim dolor vitae malesuada. Maecenas in orci in arcu dictum facilisis eget et dui. Sed sed elit sed augue cursus rhoncus gravida sit amet mauris. In vel tempor lectus. Vestibulum congue, quam et feugiat placerat, tortor urna elementum magna, et laoreet neque orci id felis. Aliquam scelerisque nisi eget nisl dignissim, id luctus dolor tempus. Etiam ornare, magna vel dictum faucibus, ante lacus interdum sem, non malesuada urna felis quis dolor. Donec faucibus sagittis elementum. Fusce id risus eu nulla ornare tincidunt iaculis id erat.
+
+Suspendisse potenti. Nunc tristique nulla ac elementum ornare. Quisque finibus vitae erat at molestie. Maecenas consectetur mollis odio eu luctus. Phasellus id velit et nunc euismod varius vel vel dolor. Duis tempus nisi eu risus laoreet porta. Sed tempor eget neque eget pharetra. Duis non massa ac sem vulputate congue. Aliquam sodales sapien nisi, ut egestas orci ornare volutpat. Ut dui libero, viverra vel turpis vitae, molestie auctor justo. Pellentesque lacinia arcu vitae nunc auctor, nec elementum lorem malesuada. Interdum et malesuada fames ac ante ipsum primis in faucibus. Interdum et malesuada fames ac ante ipsum primis in faucibus. Integer at aliquet diam. Duis sit amet orci nec urna convallis ultrices at nec nunc.
+
+Quisque rutrum eros vel ipsum tincidunt, quis pulvinar mi tincidunt. Quisque eget condimentum diam. Fusce porttitor maximus dolor et suscipit. In turpis tellus, semper hendrerit elit at, elementum fringilla nisl. Curabitur a maximus nunc. Ut dictum dignissim lectus, et convallis eros volutpat non. Sed tempor orci risus, nec fringilla nisl dictum quis. Nunc id sagittis ipsum.
+
+Fusce sollicitudin suscipit risus, tincidunt fermentum odio cursus eget. Proin tempus, felis et dignissim gravida, quam libero condimentum ligula, eget commodo libero sapien eget magna. Quisque feugiat purus mi, in facilisis augue euismod non. In euismod pharetra enim, non tristique purus dictum ac. Maecenas sed diam tincidunt, mollis neque a, imperdiet est. Sed eu orci non nulla mollis consequat et quis metus. Fusce odio metus, tincidunt ac velit sit amet, tempor posuere tortor. Vestibulum ornare, quam non vulputate feugiat, diam nibh finibus augue, at pharetra lectus nibh quis metus. Nam dignissim quis tellus eget aliquet. Proin iaculis sit amet ex eu vehicula. Etiam vehicula sollicitudin laoreet. Praesent venenatis luctus est. Suspendisse potenti. Donec luctus molestie mollis. Vestibulum quis tortor ut mauris porta gravida sed sit amet felis. Aliquam in ex condimentum, volutpat eros scelerisque, accumsan orci.
+
+Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Maecenas vitae viverra sapien. Suspendisse vel accumsan libero, ac rutrum purus. Aliquam in risus sed metus sollicitudin convallis eget in purus. Phasellus sagittis vestibulum magna, quis scelerisque augue malesuada vel. Quisque felis leo, vulputate laoreet enim lacinia, gravida viverra urna. Aliquam faucibus vestibulum maximus. Praesent scelerisque velit quis pellentesque varius. Ut consectetur ut risus a bibendum. In mollis sapien vitae ipsum volutpat, sit amet mattis nibh dictum. Curabitur eros ipsum, tincidunt et mauris id, maximus mattis sem. Mauris quis elit laoreet, porttitor nulla sit amet, feugiat tortor. Cras nec enim pulvinar, tincidunt lorem molestie, ornare arcu. Cras imperdiet quis ante vitae hendrerit. Sed tincidunt dignissim viverra.
+
+Aenean varius turpis dui, id efficitur lorem placerat sit amet. In hac habitasse platea dictumst. Integer quis pulvinar massa. Proin efficitur, ipsum eget vulputate lobortis, nibh ipsum faucibus magna, non luctus lorem nulla sed magna. Vestibulum scelerisque sed tortor eu aliquet. Curabitur et leo ac tellus pretium egestas. Cras blandit neque dui, eget dictum leo porttitor sed. Sed ultricies commodo tortor, a molestie ante scelerisque vitae. Duis faucibus quis magna nec lacinia. Morbi congue justo id dui ultricies condimentum. Pellentesque maximus faucibus gravida. Mauris vestibulum non libero sit amet fringilla. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras id lorem condimentum, sodales dui id, blandit dolor. Sed elit mauris, aliquet nec enim vitae, sollicitudin pretium dui. Cras lacus sapien, maximus in libero et, elementum fermentum nunc.
+
+Vestibulum gravida cursus nisi sed congue. Nam velit lorem, porttitor id pharetra finibus, malesuada eget dui. Vestibulum at est ultrices, venenatis nulla sed, suscipit risus. Maecenas posuere pretium odio nec accumsan. Aliquam dui dui, laoreet sed felis non, dignissim hendrerit ante. Etiam id commodo ante. Aenean bibendum enim aliquet fringilla dictum. Morbi eu feugiat risus.
+
+Praesent gravida a ante non placerat. Mauris ultricies ullamcorper justo id viverra. Aenean semper metus eu nisl euismod suscipit. Proin erat quam, viverra ut metus eget, imperdiet accumsan nunc. Curabitur non enim a odio maximus pulvinar ac et elit. In auctor ex a malesuada malesuada. Nullam dapibus quam neque, a lacinia magna tempor eget. Nam pellentesque, nisl eget gravida porta, felis magna lacinia ipsum, eu lacinia felis dui non libero. Phasellus ut convallis urna. Curabitur convallis sem vel tortor lobortis molestie. Nunc vel fringilla mi. Donec eget libero ultricies, euismod nibh non, gravida mauris. Praesent malesuada, lectus at sollicitudin interdum, mi lacus aliquam metus, non gravida tortor velit ac justo. Suspendisse auctor tellus sapien, at eleifend erat mollis et.
+
+Sed a dictum quam. Sed accumsan libero vel feugiat vulputate. Cras mattis massa nec velit rhoncus luctus. Sed ornare, augue vel ornare lobortis, purus nulla interdum ipsum, a semper massa enim quis nunc. Nunc tempor efficitur odio, vel consequat dui fringilla ac. Quisque at quam sed lacus rhoncus sollicitudin. Nunc dolor libero, dictum a ornare id, euismod ac lectus. Quisque a hendrerit lectus. Nam ut diam eu neque viverra porttitor. Proin vitae accumsan eros, ut iaculis lorem. Nulla libero odio, mollis sed venenatis et, imperdiet ut ligula.
+
+Aliquam dignissim erat erat, vel imperdiet arcu sagittis id. In in dolor orci. Aliquam congue fermentum dui tristique viverra. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Curabitur a turpis in dolor consequat pulvinar. Pellentesque sed posuere nisl. Etiam pellentesque euismod sem. Quisque vitae nibh urna. Phasellus elementum arcu urna, ac scelerisque leo iaculis non. Etiam laoreet, nunc a consectetur rhoncus, nunc tortor feugiat nibh, vitae volutpat metus mauris in est. Pellentesque at neque eu arcu faucibus auctor nec vitae urna. Suspendisse semper tristique nisl id interdum.
+
+Integer dui libero, auctor id elementum a, convallis eu est. Praesent auctor sodales faucibus. Aenean faucibus euismod orci, vestibulum pharetra magna consectetur vel. Praesent a enim vel nisi aliquam tristique ut id metus. Donec at purus dui. Sed a aliquam velit, non viverra ex. Ut molestie interdum urna vel facilisis. Nunc iaculis aliquet turpis eu luctus. Vestibulum mollis diam vel ante finibus, a efficitur est tempus. Nulla auctor cursus sagittis. Nullam id odio vitae orci tristique eleifend.
+
+Ut iaculis turpis at sollicitudin accumsan. Cras eleifend nisl sed porta euismod. Nullam non nisi turpis. Cras feugiat justo nec augue pretium fermentum. Nunc malesuada at nulla a interdum. Proin ullamcorper commodo ligula ac rutrum. Praesent eros augue, venenatis vitae enim sit amet, ultricies eleifend risus. Nunc bibendum, leo ac consequat porttitor, diam ante posuere turpis, ut mattis odio justo consectetur justo. Phasellus ex dolor, aliquam et malesuada vitae, porttitor sed tellus.
+
+Praesent vitae lorem efficitur, consequat enim ut, laoreet nisi. Aliquam volutpat, nisl vel lobortis dapibus, risus justo lacinia justo, viverra lacinia justo lorem egestas nibh. Suspendisse pellentesque justo sed interdum sagittis. Maecenas vel ultricies magna. Duis feugiat vel arcu ac placerat. In tincidunt a orci at feugiat. Maecenas gravida tincidunt nibh eu convallis. Quisque pulvinar rutrum cursus.
+
+Proin nec maximus tortor. Morbi pellentesque magna vitae risus scelerisque elementum. Nulla fringilla neque at arcu malesuada rutrum. Fusce nisi magna, elementum fringilla elit ut, lacinia varius purus. In accumsan justo ex, vitae suscipit velit finibus cursus. Morbi sed suscipit orci. Fusce nulla erat, fermentum vel aliquam vitae, eleifend et elit. Maecenas id elit a ligula vestibulum blandit ut at eros. Etiam ac bibendum massa, sagittis viverra dolor. Maecenas sed sapien nec elit fringilla molestie a vel purus. In in semper odio, quis consectetur dolor. In sed metus a nisi tincidunt posuere nec eget erat.
+
+Maecenas non auctor sem. Nullam in turpis sagittis, fermentum neque finibus, fermentum justo. Sed id nisl mattis, commodo felis in, dapibus turpis. Nullam in elit in nunc aliquam laoreet vel vitae magna. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec tincidunt tempus imperdiet. Nulla est est, mollis imperdiet varius nec, porta in nulla. Vestibulum volutpat euismod nisi vel laoreet.
+
+Cras congue egestas sodales. Nam commodo malesuada est nec volutpat. Ut gravida, turpis ac congue molestie, sapien augue molestie nulla, quis lacinia sapien dui eu nunc. Aliquam eleifend, leo et finibus pharetra, ante sapien congue purus, quis euismod urna nulla et metus. Donec vulputate hendrerit tortor quis mollis. Vestibulum et condimentum purus, vel aliquam lacus. Ut id congue sapien. Pellentesque ante lectus, hendrerit sit amet luctus quis, feugiat dignissim leo. Aenean aliquam imperdiet cursus. Praesent vulputate turpis ullamcorper felis tincidunt tincidunt. Duis quis augue vitae nibh finibus sagittis. Sed sollicitudin scelerisque tellus, ut interdum diam sollicitudin bibendum. Vestibulum iaculis fermentum sem sit amet tempus. Suspendisse lobortis eleifend fermentum.
+
+Etiam consectetur est sit amet nisl aliquet, eget fermentum tellus rhoncus. Quisque vulputate sit amet mauris eget lacinia. Fusce ac eros tellus. Suspendisse et tellus felis. Praesent ultricies nunc lorem, sed sodales orci viverra eu. Vestibulum maximus nibh et turpis efficitur, in tempus ipsum efficitur. Vivamus finibus lorem nec malesuada egestas. Praesent in nibh sagittis, volutpat risus et, commodo est. Suspendisse facilisis eu augue nec tincidunt. Fusce quis nisl tempus, tincidunt lacus nec, dapibus purus.
+
+Vivamus et ante eu ante sodales elementum sed id urna. In tincidunt vel tortor sed feugiat. Praesent iaculis diam eget pellentesque ornare. Praesent aliquet convallis odio sit amet suscipit. Morbi et nisi nulla. Nunc vestibulum risus a faucibus efficitur. Pellentesque commodo odio eu leo vestibulum, id iaculis risus sagittis. Cras a ipsum posuere, rhoncus eros in, euismod nulla. Nam semper, mi id tempor sodales, diam sem blandit odio, eget posuere tellus nisi nec tortor. Etiam nec tortor congue, sodales ante ac, malesuada elit. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Fusce fringilla eros sit amet orci vestibulum aliquam. Suspendisse fermentum malesuada est, sit amet condimentum ante volutpat nec. Integer sit amet magna molestie, feugiat odio a, condimentum lectus.
+
+Nullam odio ligula, mollis eu massa ac, maximus interdum velit. Vestibulum vulputate a justo ac efficitur. Quisque ex est, pretium id velit nec, malesuada posuere arcu. Sed congue lacus nec velit vehicula, a egestas erat mattis. Nunc eget leo a metus rhoncus mollis. Maecenas at elit nec est condimentum suscipit. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Duis nisi mauris, consequat varius mollis at, porta ac dolor. Mauris vitae euismod lorem, ut dapibus turpis. Vivamus sit amet iaculis turpis. Nulla molestie feugiat urna in pharetra.
+
+Nam ac elit vulputate magna venenatis pharetra ac eu elit. Donec sed eros id lacus molestie rutrum. Sed iaculis mauris nunc, non fringilla ante semper eu. Maecenas in auctor eros. Vestibulum eu enim lorem. Etiam tristique dui id justo blandit dignissim. Aenean quis faucibus eros. Quisque vel dolor lectus. Etiam lacus enim, laoreet varius dolor ut, sollicitudin imperdiet lacus.
+
+Quisque vel nibh sollicitudin urna pellentesque euismod sed sed lorem. Suspendisse in condimentum ipsum, eu convallis ipsum. Nunc faucibus condimentum ante efficitur imperdiet. Donec tempor egestas efficitur. Morbi et aliquam nisl, quis iaculis elit. Fusce eu elit et sapien auctor ullamcorper. Curabitur sem orci, pharetra vitae facilisis non, scelerisque et mi. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Ut molestie eu velit id ultricies. Maecenas vehicula id tortor sit amet faucibus. Duis porta enim nec vestibulum posuere. Aenean blandit fringilla lacus accumsan pellentesque. Integer ut ante elementum, imperdiet metus sit amet, consequat orci.
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce eget libero non arcu luctus pulvinar. Vestibulum condimentum tellus nec enim bibendum aliquam. Nulla non placerat massa. Donec vestibulum nibh at rutrum mollis. Aliquam erat volutpat. Vivamus metus est, rhoncus a efficitur id, blandit id dolor.
+
+Nunc rutrum lacus ut pharetra feugiat. Sed volutpat semper metus sit amet placerat. Phasellus efficitur porta venenatis. Quisque imperdiet metus nunc, nec porttitor turpis iaculis ut. Sed at orci eget eros lacinia volutpat. Etiam sagittis euismod diam quis ullamcorper. Nulla facilisi. Praesent faucibus neque vel tortor pharetra, ac tincidunt nunc rutrum. Phasellus aliquam nulla in augue rhoncus, a lacinia tellus pretium.
+
+Praesent in mauris lectus. Aliquam molestie nulla vitae nulla consectetur convallis. Sed eu molestie velit, vitae venenatis elit. Quisque eget ultricies mauris, at euismod risus. Sed gravida velit ut risus tempor suscipit. Maecenas metus nisi, pellentesque in ornare et, fermentum et lectus. Interdum et malesuada fames ac ante ipsum primis in faucibus.
+
+Quisque in mi congue, molestie massa a, fermentum tellus. Integer vitae tortor iaculis, tincidunt magna et, egestas ligula. Sed feugiat metus id erat faucibus, ac bibendum enim sollicitudin. Cras hendrerit massa sapien, et consequat tellus accumsan lacinia. Nam pharetra, ipsum ut vestibulum fringilla, sapien eros finibus leo, eget suscipit nibh arcu aliquam quam. Quisque sollicitudin id est eu rutrum. Nunc vitae tincidunt nisi, euismod viverra enim. Maecenas mattis sapien at felis hendrerit dignissim.
+
+Quisque eu urna nulla. Integer at eros fermentum est mattis rutrum at nec massa. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Etiam ut hendrerit nunc. Vestibulum est velit, rhoncus quis nisi sed, lobortis aliquet metus. Nunc faucibus egestas magna sit amet ornare. Maecenas eu justo mi. Proin tincidunt sem vel metus efficitur, sit amet malesuada augue cursus.
+
+Vestibulum viverra augue ut lorem accumsan, nec lacinia ligula accumsan. Maecenas viverra mauris dolor, vitae molestie mi accumsan nec. Ut nec sagittis nisl, fringilla viverra magna. Cras condimentum ultrices sollicitudin. Morbi tempor, massa ut iaculis posuere, arcu erat luctus massa, vitae pulvinar nulla ex nec nulla. Mauris vitae scelerisque ipsum. Nullam tincidunt consequat augue, quis aliquam nulla. Integer non arcu erat. Etiam scelerisque sodales vestibulum. Sed luctus arcu eu leo consectetur, at porta arcu elementum.
+
+Morbi in eleifend neque. Quisque a blandit libero, dignissim porta tortor. Sed nunc metus, aliquam a elit et, sagittis dictum arcu. Vestibulum lacinia nisi quis luctus ultricies. Fusce erat eros, euismod sit amet luctus vel, tempor a nunc. Aliquam nec nulla id est molestie tincidunt ac sit amet arcu. Donec molestie laoreet sapien, sit amet vulputate turpis facilisis at. Nullam eget nisi vel nibh elementum euismod non tempus leo. Nulla suscipit consectetur ante, nec fringilla lectus porta ac. Proin nec odio in lacus suscipit lacinia et sagittis ante. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Sed rhoncus lacinia porttitor. Pellentesque sapien ipsum, sagittis posuere arcu ut, laoreet gravida elit. Aenean eu tortor sit amet massa tincidunt facilisis. Aenean congue eget orci vitae vestibulum.
+
+Nunc tempus augue rhoncus condimentum vehicula. Sed in dui sit amet arcu varius pellentesque quis cursus nisl. Proin faucibus erat id egestas suscipit. Nam accumsan in tellus nec elementum. Phasellus nunc orci, mattis nec sollicitudin ultrices, feugiat eu lectus. Morbi ullamcorper rutrum sapien non rhoncus. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Quisque orci sapien, fringilla et dictum sit amet, tristique vel arcu. Maecenas tempus porttitor mattis. Cras eget faucibus enim.
+
+Mauris ornare mattis tortor. Duis convallis a ipsum id cursus. Aenean viverra, eros pellentesque ullamcorper posuere, orci ligula luctus odio, vel rutrum ex lectus eu erat. Etiam mollis nulla orci, fringilla gravida mauris viverra eu. Sed et orci non purus ultricies elementum. Cras at lectus hendrerit, fringilla lacus nec, feugiat sem. Morbi in metus felis. Etiam tempor bibendum ex eu venenatis.
+
+Cras ac nibh condimentum, lacinia sem ut, pretium felis. Sed congue, mi at accumsan semper, felis lorem vestibulum nisl, ac commodo lorem eros at mi. Curabitur condimentum nunc justo. Nulla efficitur venenatis nibh sed finibus. Integer iaculis volutpat mi dictum bibendum. Nullam tempus id ante euismod placerat. In placerat auctor lacus ac molestie. Aenean ultricies egestas imperdiet.
+
+Ut interdum cursus accumsan. Aliquam a mi ligula. Nunc blandit, metus in pellentesque aliquet, velit libero aliquam quam, nec egestas est turpis at ante. Quisque et magna eget massa gravida suscipit. Ut in lectus a massa eleifend sagittis rhoncus faucibus lectus. Maecenas sit amet elit vel tellus varius feugiat ac ut diam. Ut iaculis non ante in molestie. Integer pulvinar vulputate velit, ornare dignissim sapien laoreet ut. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas.
+
+Aliquam finibus tristique laoreet. Pellentesque et diam tincidunt orci hendrerit euismod. Phasellus viverra orci vitae interdum imperdiet. Phasellus gravida auctor nisi, vitae rhoncus est dignissim eget. Phasellus eu facilisis eros, vitae iaculis quam. In condimentum velit non iaculis porta. Proin ipsum ex, egestas nec molestie sit amet, vehicula sed ante. Proin eget eros at nibh sollicitudin luctus a id magna. Nam eget turpis finibus, tempor libero nec, auctor velit. Nunc neque magna, dictum vel semper nec, facilisis eu lectus. Maecenas maximus tortor eget ex dictum, sit amet lacinia quam tincidunt. Nulla ultrices, nunc ac porta feugiat, diam dolor aliquet sapien, sit amet dignissim purus ante in ipsum. Maecenas eget fringilla urna. Etiam posuere porttitor interdum. Vestibulum quam magna, finibus et urna auctor, pulvinar viverra mauris. Fusce sollicitudin ante erat.
+
+Maecenas pretium facilisis magna, at porttitor turpis egestas non. Morbi in suscipit felis. Duis eget vehicula velit, posuere sodales lorem. Curabitur elementum a lectus non ornare. Donec vel eros scelerisque ipsum iaculis accumsan. Phasellus tincidunt tincidunt lobortis. Vestibulum maximus risus tellus, eu faucibus urna tincidunt quis. Fusce dignissim lectus vel enim ultricies, in efficitur purus semper. Etiam sit amet velit pulvinar, hendrerit erat et, maximus eros.
+
+Maecenas iaculis convallis consectetur. Duis ante nulla, commodo sit amet diam sed, tempus mattis risus. Maecenas volutpat leo leo, in mollis eros mollis quis. Aenean sagittis, neque id mattis varius, tortor leo cursus ligula, a ultricies justo turpis ut libero. Ut sit amet nibh et erat pellentesque rhoncus. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Integer rhoncus ligula nec iaculis faucibus. Curabitur tincidunt eu diam eget ultrices.
+
+Vestibulum quis nisl nec lacus commodo efficitur eu eleifend turpis. Etiam pretium id nisl a vehicula. Praesent elementum malesuada nisl. In condimentum interdum faucibus. In sed mauris vestibulum dui ultricies congue. Ut posuere mattis ante, in blandit mauris suscipit quis. Pellentesque ligula turpis, tincidunt a laoreet vel, consectetur in est. Nulla gravida ligula vel lectus faucibus accumsan. Praesent rhoncus eros arcu, id ultrices ipsum maximus ac. Mauris tincidunt cursus erat nec vulputate. Nulla tristique imperdiet eros vitae lobortis. Nullam a urna et sem condimentum blandit sed ut nulla.
+
+Maecenas auctor sodales facilisis. Pellentesque facilisis augue a odio varius suscipit. Etiam malesuada justo vel leo dignissim tincidunt. Sed magna metus, sagittis at diam gravida, dictum iaculis sem. Aliquam erat volutpat. Maecenas euismod egestas tortor non sollicitudin. Nulla quis odio tincidunt, auctor est sed, pretium turpis. Quisque aliquet semper magna, sit amet gravida enim luctus at.
+
+Nulla orci risus, ultrices a nunc et, dictum tincidunt lectus. Aliquam erat volutpat. Mauris at justo feugiat, efficitur lectus id, facilisis turpis. Sed ornare sodales fermentum. Suspendisse interdum tellus ac auctor sagittis. In auctor convallis metus non elementum. Mauris id dolor aliquam, euismod sapien id, tristique mi. Duis ac eleifend lectus. Etiam odio turpis, molestie vitae posuere vel, feugiat ac lorem. Fusce tempus ligula non hendrerit maximus. Nulla facilisi. Ut pretium turpis eget eros fringilla, vel aliquam mi pulvinar.
+
+Donec rhoncus augue ac viverra lacinia. Aliquam suscipit risus id sem varius, eget aliquet justo varius. Phasellus molestie, neque vitae semper posuere, est risus blandit ligula, id lacinia lectus orci id lectus. Cras vitae massa sit amet sapien pulvinar sollicitudin facilisis sed leo. Donec risus nulla, finibus id nulla quis, ornare sollicitudin neque. Curabitur id sapien vehicula, tempor velit sit amet, auctor augue. Nunc venenatis urna quis ante mollis bibendum.
+
+Pellentesque in varius massa. Donec non odio ultricies purus hendrerit fermentum. Aliquam quis elit vitae risus porttitor efficitur in vel sapien. Vestibulum sed urna sed lorem convallis bibendum nec non eros. Nullam molestie accumsan tincidunt. Aenean interdum sapien quis sapien dictum porttitor. Ut sit amet mollis magna, sed finibus urna. Etiam porta congue nunc eu aliquam. In congue mollis tincidunt. Nunc id metus ultricies, aliquam risus vel, sollicitudin dui. In nec felis consectetur, gravida dolor eu, consectetur lorem. Ut hendrerit, velit vitae malesuada placerat, felis metus vehicula odio, in iaculis ex tortor id metus. Donec mattis elit a est sollicitudin, in lacinia nisi gravida. Nullam ornare, tellus eget pharetra mollis, purus nisl condimentum sapien, vel ultricies enim libero ac ex. Fusce sed ligula a arcu lacinia tempor sit amet et magna. Maecenas fermentum nec diam in ornare.
+
+Cras pellentesque facilisis accumsan. Curabitur vehicula volutpat diam, vel tincidunt felis cursus sed. In malesuada leo et porta pulvinar. Integer at ultrices nunc, a tincidunt metus. Vivamus eu tellus vel lectus volutpat fringilla. Donec ut egestas est. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce non hendrerit turpis. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Etiam in ipsum quis ipsum hendrerit egestas. Donec vitae lectus malesuada, consequat enim et, lobortis velit. Vestibulum nec augue ex. Nullam ut porta lacus. Morbi pellentesque gravida purus, a interdum felis. Nulla lacus libero, euismod quis posuere in, congue pretium ipsum. Aliquam at suscipit nisi.
+
+Sed et venenatis purus, at maximus dolor. Fusce varius eget turpis ac sodales. Nullam sed mauris quis diam hendrerit dapibus consectetur eget dolor. Suspendisse maximus ac velit quis condimentum. Praesent ac mattis mauris. Morbi aliquet dignissim sem, sed mattis enim vestibulum vitae. Morbi sed dui in sapien elementum ullamcorper. Proin feugiat viverra ipsum et commodo. Nam pellentesque turpis nec condimentum aliquam.
+
+Praesent luctus elit sit amet est fermentum, nec egestas lectus scelerisque. Proin ornare mi eu turpis sodales, at vestibulum magna placerat. Suspendisse potenti. Nulla vel elit semper, blandit nunc vel, ullamcorper turpis. Morbi eu posuere sapien, ac iaculis tellus. Etiam tincidunt nunc vitae cursus faucibus. Phasellus rhoncus sollicitudin metus, id lobortis mi iaculis nec. Donec elementum venenatis purus at commodo. Aenean egestas facilisis metus, quis posuere nisi fringilla aliquam. Fusce ac porta nibh. Aliquam hendrerit lectus magna, at auctor felis viverra a. Integer elementum posuere nunc a fringilla.
+
+Nunc metus lectus, molestie nec tincidunt at, facilisis id enim. Aenean nulla quam, convallis non lectus vehicula, dignissim interdum velit. Ut vestibulum finibus mauris. Vivamus sed euismod elit, ut pulvinar dolor. Suspendisse dictum viverra pharetra. Curabitur non erat finibus orci sodales pulvinar. Sed at consectetur quam, ut commodo lacus. Suspendisse mollis convallis lorem, nec venenatis nunc lacinia a. Proin in est dui. Nunc nec lacus lectus. Aenean faucibus dui ornare magna varius fermentum. Aenean eu justo pulvinar libero rhoncus sollicitudin at et nunc. Integer sit amet mauris hendrerit, fringilla magna quis, tincidunt nunc. Fusce sit amet aliquam leo, pretium fermentum nisl. Vestibulum hendrerit tempus suscipit.
+
+Pellentesque et augue varius, aliquam justo vel, sagittis erat. Suspendisse tincidunt maximus velit, porttitor interdum ligula elementum vel. Nunc a dictum lectus, gravida tristique magna. Quisque id risus arcu. Vestibulum porta in mi sed finibus. Nam tristique in mauris nec gravida. Vivamus arcu sem, fringilla ac purus eget, vestibulum posuere arcu. Integer aliquet elit a est scelerisque pharetra vel sit amet augue. Sed quis finibus nunc, non ornare felis. Suspendisse potenti. Maecenas sollicitudin eros urna, vel bibendum mi sollicitudin facilisis. Nam elementum ligula non augue accumsan, ut laoreet tellus ultricies. Nunc in pellentesque quam. Proin eu varius lectus. Donec gravida massa non rhoncus dignissim. Sed est sapien, vestibulum ac egestas nec, posuere id metus.
+
+Phasellus quis interdum felis. Pellentesque ac elementum lacus. Proin posuere tempor ante, et consectetur nulla convallis ut. Etiam porta sem orci, eget convallis risus hendrerit in. Mauris gravida libero id tincidunt lacinia. Donec tempus ultrices ipsum, vitae finibus velit. Sed consectetur dictum velit, in consequat dolor fermentum eget. Pellentesque porttitor tellus velit, quis dignissim purus imperdiet et. Phasellus leo lectus, mollis nec ultricies ut, placerat ut quam. Integer imperdiet mauris sed magna gravida accumsan. Nulla congue turpis at urna tincidunt, at tempus urna condimentum. Praesent ac nibh lectus. Pellentesque id odio at purus tincidunt mollis nec id massa. Nulla eget venenatis erat, ornare lobortis nulla. Fusce rhoncus metus turpis, at mattis magna blandit sed. Aliquam sed mattis massa, ut bibendum nisl.
+
+Mauris commodo vulputate nulla at sodales. Vivamus sagittis viverra ex, in scelerisque dui commodo in. Maecenas eget ante euismod, tristique tortor at, placerat turpis. Fusce hendrerit, orci et hendrerit tristique, turpis tortor hendrerit elit, vel dictum eros nisl vitae enim. Nullam et lacus velit. Donec rutrum tortor risus, eu volutpat lorem placerat tempor. Etiam rhoncus lorem quis turpis gravida placerat. Nam at magna efficitur, interdum mauris vel, tristique odio. Phasellus augue nisl, fermentum luctus sapien non, rhoncus convallis dui. Aenean nibh tellus, congue ut nulla eu, luctus lacinia est. Sed vel augue tellus. Ut congue sit amet risus ut consequat. Vestibulum id magna sed augue condimentum porttitor. In nec leo ac justo condimentum dignissim. Nullam eu gravida ipsum.
+
+Proin iaculis imperdiet nisl. Vestibulum at lectus bibendum ipsum mattis viverra. Suspendisse facilisis non nulla non dignissim. Interdum et malesuada fames ac ante ipsum primis in faucibus. Fusce scelerisque turpis ante, tincidunt laoreet risus pharetra in. Nam nisi est, hendrerit in tincidunt sit amet, accumsan placerat odio. Vivamus nec egestas ligula. Nam sit amet dignissim nulla, sit amet lobortis ex.
+
+Etiam ac tellus lectus. Cras egestas urna id ornare vestibulum. Donec ut magna id velit finibus sagittis eget at nibh. Pellentesque tempus tempor justo, sit amet rutrum massa convallis eu. Ut lacus quam, sollicitudin vel consectetur vel, cursus eu velit. Sed aliquam ex a est lacinia pretium. Sed volutpat dui at iaculis accumsan. Nam feugiat libero a ante consectetur, nec maximus metus venenatis.
+
+Fusce in nunc lorem. Aliquam vel tincidunt nisl. Duis sed laoreet dui. Nam eu dapibus lacus. Nulla odio lectus, ornare sit amet leo sed, laoreet tempus massa. Curabitur venenatis ipsum vel turpis lacinia, sed euismod diam commodo. Etiam ac turpis cursus, auctor lectus eu, sodales ex. Ut eget dolor aliquet mauris maximus volutpat vitae ut lorem. Sed vulputate arcu ex, a porttitor risus porttitor vel. Duis sed accumsan purus.
+
+Pellentesque nisi est, scelerisque eu magna in, venenatis dapibus elit. Morbi porttitor, lectus dapibus dapibus sodales, mauris eros tristique metus, vitae porta tellus quam eu arcu. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Nam fringilla nibh sed fermentum vestibulum. Aliquam quis mollis elit. Etiam lobortis purus sed nunc pulvinar malesuada. Morbi varius mattis velit efficitur convallis.
+
+Pellentesque facilisis ante id metus porta, et tincidunt quam tristique. Proin non sem vel eros venenatis tempor. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Vivamus sollicitudin non risus at mollis. Cras leo orci, tempus eget felis a, efficitur tincidunt massa. In quis augue tristique, condimentum nulla eget, vulputate sem. Sed purus neque, ultricies eu turpis facilisis, dignissim bibendum eros. Vivamus congue accumsan dui. Sed congue dolor ut nisl mattis laoreet eu eu purus. Mauris vehicula, quam vel feugiat imperdiet, libero nibh commodo mi, at ullamcorper nulla enim sed leo. In eget ante sit amet metus luctus vulputate non sed dolor. In sapien odio, egestas sit amet sapien quis, congue mattis ante. Quisque tempus ligula ut eleifend facilisis. Vivamus ornare suscipit laoreet. Nulla vitae placerat massa, interdum sollicitudin augue.
+
+Suspendisse potenti. Morbi sed scelerisque diam. Suspendisse vitae tortor arcu. Nullam a ligula condimentum, sollicitudin arcu et, fringilla elit. Vivamus dignissim gravida ornare. Etiam scelerisque ligula at est porta, in dignissim sem hendrerit. In ut mollis urna. Sed blandit purus at volutpat scelerisque. Nullam vel finibus odio. In eu neque eu ante pretium posuere. Nullam vitae accumsan neque. Nam nec elit dolor. Ut sit amet urna eros. Maecenas efficitur dui id tempor porta. Pellentesque et quam felis.
+
+Proin aliquet sem nec ipsum porta, eu tempus velit vestibulum. Nulla sed ligula sed metus sollicitudin porttitor. Fusce non posuere lacus. Phasellus luctus, eros quis rhoncus ultricies, arcu tellus rutrum tellus, eu vulputate orci ante vitae lorem. Maecenas porttitor mauris purus, ut eleifend metus sollicitudin sit amet. Curabitur ultricies erat id libero egestas, ut ullamcorper eros vehicula. Vestibulum lorem nibh, aliquam ut tincidunt elementum, tempor quis sem. Donec vehicula tempor eleifend. In hac habitasse platea dictumst. Nunc ut sem elementum, aliquam dolor sit amet, eleifend enim. In elementum viverra mi, eget pulvinar lorem fermentum non. Nam ac ligula vel dolor convallis pellentesque. In sed lectus sed arcu consequat finibus vel et ante. In iaculis id tellus in congue. Donec imperdiet lorem quis erat maximus, vitae molestie ex accumsan. Donec pharetra, orci ac rutrum pretium, nunc mauris vestibulum magna, sagittis consequat risus orci ut felis.
+
+Sed id metus eget odio suscipit efficitur id eget ligula. Phasellus massa metus, varius et metus quis, porta lobortis turpis. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. In in augue semper, consequat nunc at, tristique eros. Nullam vitae consectetur neque. Duis dignissim urna metus, vitae condimentum erat eleifend ac. In pellentesque nunc sed convallis sagittis. Integer venenatis, felis a mollis tristique, diam neque laoreet orci, ac varius diam ligula pulvinar augue. Nullam dapibus libero id est sollicitudin, non efficitur dui sollicitudin. Mauris sem diam, feugiat non ante elementum, eleifend lobortis urna. Nullam pharetra tristique diam in aliquam. Donec finibus sit amet lectus non auctor.
+
+Ut nibh tortor, sagittis ut sem eget, ultricies auctor enim. Cras malesuada ligula velit, sit amet consequat mauris interdum eget. Curabitur fermentum tristique magna facilisis ultricies. Sed quis porta arcu. Ut in nunc id velit egestas consectetur. Nulla fermentum porta nisi, vitae dapibus risus consectetur faucibus. Mauris quis magna aliquam libero dictum porta. Mauris sed iaculis turpis, non auctor turpis. Sed eget lorem ex. Sed pulvinar, mi ut rhoncus dapibus, est lorem maximus orci, ac tempor justo erat vel purus. Proin euismod turpis eu ex blandit semper. Nulla suscipit molestie ex sed auctor. In facilisis nisi convallis nulla rutrum bibendum. In aliquet leo eget quam auctor, at eleifend felis commodo.
+
+Vivamus at elit scelerisque, tristique mi non, ornare nisl. Integer posuere orci diam, sit amet malesuada nisl vestibulum ut. Sed convallis urna id arcu luctus, faucibus interdum urna varius. In hac habitasse platea dictumst. Mauris laoreet mauris vel nisi ultrices facilisis. Suspendisse mattis purus eu dui lobortis bibendum. Fusce cursus risus tellus, non fermentum lectus tristique sed. Curabitur ullamcorper tincidunt tortor vel blandit. Quisque at ligula ut sapien convallis tincidunt eu vitae dolor. Etiam consectetur lacinia sollicitudin. Sed sagittis dolor vel nulla congue mollis. In ut felis gravida, luctus massa sed, venenatis ante. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Nunc facilisis lobortis dapibus.
+
+In a velit nibh. Nam mollis nunc sed faucibus eleifend. Sed maximus malesuada ultrices. Donec mattis finibus nunc, eu viverra massa egestas non. Donec arcu velit, sagittis et tempor mollis, malesuada in mi. Duis rhoncus suscipit lorem ac lobortis. Vestibulum malesuada nibh at nulla ornare, at pulvinar magna tincidunt. Ut tellus risus, commodo vitae fringilla nec, semper quis nulla. Suspendisse euismod eros vel leo commodo, ac sollicitudin velit porta. Donec non dolor blandit, tempor magna eu, suscipit risus. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Donec libero nisl, auctor in rhoncus sed, viverra a arcu. Etiam diam ex, luctus non ultrices quis, viverra ut quam. Mauris lobortis suscipit quam, malesuada pretium nibh ultrices non. Suspendisse molestie, risus sit amet venenatis semper, justo justo tempor tortor, vel iaculis ligula dui sed erat.
+
+Donec odio ligula, aliquam id mollis eget, tincidunt nec arcu. Duis aliquam elementum facilisis. Vivamus lobortis fermentum egestas. Etiam ac orci sit amet dui dignissim condimentum. Maecenas magna arcu, mollis eget nisl a, vestibulum finibus lacus. Praesent et metus risus. Morbi semper neque vel erat fermentum, commodo posuere sem porta. Proin sit amet ipsum at lectus vestibulum luctus. Nullam convallis nulla ac pretium facilisis. Nunc porttitor convallis mi nec vestibulum. Phasellus vehicula vestibulum ornare. Curabitur commodo sapien quis vulputate egestas. Suspendisse potenti. Vestibulum quis mattis nisi.
+
+Maecenas mattis ex eget placerat aliquet. Pellentesque est nibh, ultrices eu laoreet in, interdum vitae nunc. Suspendisse sit amet metus hendrerit, fringilla quam at, mollis arcu. Nullam tempus metus volutpat felis fermentum, et accumsan nisl placerat. Maecenas pharetra feugiat eros sit amet consectetur. Donec vehicula tincidunt massa eu sagittis. Integer massa nisl, luctus quis nisi et, molestie cursus turpis. Aliquam congue ipsum eget turpis vehicula, commodo eleifend neque placerat. Nam vel consequat urna. In pellentesque lobortis tempus. Pellentesque pharetra, purus in pretium convallis, turpis orci maximus tortor, eu malesuada ex elit sit amet lorem.
+
+Curabitur sit amet aliquet quam, non aliquet tellus. Pellentesque nec ipsum dolor. Aliquam blandit gravida dolor vitae porta. Integer enim purus, scelerisque id molestie sed, accumsan vel nulla. Aenean vel ultricies urna. Nam consequat ipsum tempor mi placerat, id pretium dolor cursus. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae;
+
+Sed venenatis dui mauris, pellentesque varius magna malesuada blandit. Etiam sed tempor ipsum, id tincidunt nisl. Sed a felis mi. Nulla orci metus, auctor ac malesuada lobortis, facilisis vel nisl. Pellentesque at scelerisque est. Nulla vel mi ut magna commodo lobortis in ut diam. Etiam a lacus dui. Integer ut turpis arcu. In hac habitasse platea dictumst. Quisque porta neque at velit eleifend consequat. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Aliquam erat volutpat. Nam pretium turpis a sem placerat, non mollis diam dictum. Sed at nulla purus.
+
+Sed auctor neque nec consectetur sollicitudin. Donec aliquam arcu id diam commodo posuere. Nulla nec accumsan ante, at fringilla ligula. Sed nisi libero, iaculis ut convallis nec, ultrices ac ex. Mauris aliquam mi nec ultricies porttitor. Mauris malesuada odio ut hendrerit tempus. Aliquam non aliquam dui. Nam mi mauris, volutpat in ligula vel, blandit iaculis lectus.
+
+Integer vel maximus massa, sit amet mollis nibh. Proin at aliquet sapien. Nullam a turpis id libero facilisis dignissim. Sed convallis nulla vitae turpis consectetur, eu pharetra libero posuere. Interdum et malesuada fames ac ante ipsum primis in faucibus. Morbi venenatis massa id massa commodo suscipit. Cras magna lorem, porta eget velit at, vehicula semper velit. Maecenas cursus libero sit amet eleifend tempus. Suspendisse sed odio nisi. Suspendisse pulvinar felis semper magna hendrerit, ac posuere neque ullamcorper. Vivamus aliquam, elit id vulputate convallis, dolor lectus tempor nisi, id dapibus nulla eros in dui. Pellentesque ante libero, eleifend ac consequat vel, sodales in enim. Proin gravida sapien in nulla cursus, sagittis faucibus quam aliquam. Phasellus sit amet diam molestie, luctus urna eget, convallis elit. Nunc interdum erat fringilla, finibus neque quis, scelerisque justo. Donec interdum id risus at pharetra.
+
+Cras finibus magna turpis, sollicitudin viverra felis bibendum sagittis. Cras blandit facilisis euismod. Curabitur finibus enim gravida erat faucibus rhoncus. Aenean tempor elit vel sem ornare viverra. Ut at tortor nisl. Aenean in quam enim. Mauris pulvinar augue at nunc commodo, eget efficitur turpis laoreet. In vel fermentum nisi, eget porttitor diam. Mauris placerat eu ligula eu cursus. Curabitur ac tincidunt dolor, eu molestie est. Quisque ullamcorper vehicula faucibus. Phasellus euismod, arcu a scelerisque tempor, massa lectus ultricies velit, at mattis mauris mauris ultricies arcu. Proin condimentum ultrices nisl a rutrum. Proin bibendum sem quis accumsan fermentum.
+
+Integer sit amet velit sed urna rutrum molestie id non nunc. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Phasellus ac ornare dolor. Quisque ante massa, tincidunt eget iaculis sit amet, dapibus vitae arcu. Fusce sagittis leo eu varius egestas. Nam a ex non tellus vestibulum consequat sit amet ac est. Donec mi purus, varius non finibus sit amet, maximus ut mauris. Etiam a sapien lacinia, faucibus massa non, tempus libero. Aliquam ac lorem id purus vehicula consectetur quis non metus.
+
+Nam id imperdiet nulla, eu luctus sem. Nunc non risus vel quam dapibus porta. Aliquam laoreet dictum tristique. Curabitur et varius leo. Nulla hendrerit sem at tellus sodales, in porta nisl cursus. In et tincidunt tellus, vel commodo nulla. Etiam mattis dolor vestibulum libero aliquet, eget accumsan mi iaculis. Aenean in lacus congue, iaculis ipsum eu, condimentum ligula. Cras lorem leo, eleifend eget risus at, efficitur malesuada turpis.
+
+Suspendisse potenti. Pellentesque laoreet neque quis molestie finibus. Mauris id sapien in dui efficitur feugiat ut efficitur justo. Mauris quis faucibus ante. Suspendisse interdum sodales purus, sed semper ante venenatis vel. Aliquam rutrum, magna ut faucibus molestie, tortor ante iaculis nisi, in sollicitudin tellus arcu nec ex. Donec eu accumsan orci.
+
+Integer elementum metus rhoncus hendrerit molestie. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Mauris efficitur ultricies orci eget vulputate. Etiam pharetra sem lacus, eu convallis lacus fringilla vitae. Nunc accumsan volutpat tincidunt. Nam non mauris pretium urna iaculis venenatis. Aenean tempor tortor a urna eleifend maximus. Donec ornare dui non ornare bibendum. Phasellus suscipit posuere lacus ac vestibulum. Pellentesque sit amet eleifend quam, fermentum pharetra diam. Vestibulum in porta sapien. Aenean in rhoncus dui. Quisque euismod, metus non luctus vulputate, sem diam maximus lorem, porttitor volutpat est justo sed sapien. Etiam maximus eros eu elit cursus elementum.
+
+Nunc ut aliquet dolor. Nam nunc nibh, consequat non mollis eget, dignissim a sapien. Aenean luctus suscipit massa id pharetra. Vestibulum eget velit vitae lectus porttitor blandit vitae eget odio. Pellentesque ullamcorper finibus massa at pretium. Nunc nec sapien at lacus vehicula dictum sed quis elit. In vitae sem urna. Sed porttitor sodales ante, ut varius justo blandit eu.
+
+Proin faucibus tempus velit, nec bibendum mauris bibendum vitae. Sed auctor, massa feugiat tristique iaculis, massa dolor accumsan eros, feugiat blandit odio diam ut purus. In at magna semper, mollis risus et, viverra lectus. Ut diam nibh, ultrices id tellus eget, venenatis auctor orci. Praesent eget semper orci. Proin vel nisl leo. Nulla sit amet mi quis eros feugiat rutrum sed vel dolor. Ut ullamcorper ultrices est vel tincidunt. Mauris a tortor nec nibh egestas interdum et quis lectus. Etiam vitae rhoncus tellus. Quisque facilisis odio at justo tempus consectetur.
+
+Duis vitae diam nec odio pulvinar eleifend. Suspendisse convallis lacus sit amet nunc elementum sodales. Integer commodo accumsan lacinia. Aliquam dapibus dolor dolor, a laoreet augue finibus et. Integer faucibus sapien ac interdum lobortis. Vestibulum blandit varius eleifend. Nunc id lobortis ipsum. Nunc porttitor et risus quis interdum. Integer ante lectus, cursus et urna tincidunt, fringilla varius arcu. In bibendum quis turpis efficitur laoreet. Etiam sollicitudin dictum diam, euismod luctus ante varius sed. Cras vel hendrerit risus. Morbi et leo fermentum, tincidunt ligula ultrices, tempus arcu. Quisque non arcu at mauris luctus tempus eu vitae erat. Morbi ut est ac orci vulputate tincidunt id ac lorem.
+
+Mauris et sodales tellus. Curabitur metus orci, fermentum sed est in, porttitor fermentum mauris. Aliquam mollis elit nulla, in varius lectus tempus eget. Sed lacinia tempus lacus, sed pulvinar nulla congue a. In a congue est, vitae egestas nisi. Aenean interdum, leo ac fermentum suscipit, sapien dui luctus diam, non iaculis massa felis id ligula. Sed euismod placerat nunc quis tempor. Sed eu leo luctus, pretium elit vitae, laoreet dolor. Mauris aliquet ac lectus malesuada sagittis. Suspendisse placerat tincidunt nisi, id semper urna consequat at. Suspendisse sollicitudin eu augue sit amet faucibus. Ut vitae justo sagittis, euismod tortor vitae, ullamcorper dolor. Suspendisse ultricies at enim ac congue. Curabitur auctor neque lectus, nec condimentum sem eleifend et.
+
+Nullam id sem in risus vulputate facilisis. Sed iaculis ante sit amet iaculis luctus. Suspendisse ut aliquet sapien, eget hendrerit nisi. Ut malesuada velit dui, a egestas odio dapibus a. Phasellus rutrum sit amet dui vulputate ultrices. Maecenas iaculis ex eu tortor lacinia, consequat maximus mi tempus. Vestibulum neque odio, accumsan eu ornare ut, elementum sed lacus. Nulla ipsum leo, consectetur in ullamcorper sit amet, volutpat sit amet nulla.
+
+Praesent tincidunt, justo et venenatis mattis, enim ex lobortis elit, ut tristique dui eros eu urna. Suspendisse sodales tellus quam, nec hendrerit sem mollis vel. Duis nunc nulla, mollis eu nisl et, sagittis volutpat sem. Fusce dolor turpis, dapibus quis sollicitudin in, semper vitae felis. Fusce id ante velit. Praesent ac ornare velit. Proin non erat quis neque accumsan iaculis. Donec faucibus orci at malesuada finibus. Nam venenatis tempus venenatis.
+
+Aenean vel risus ultricies, tempor augue id, pretium diam. Aenean at nunc orci. Cras sit amet tortor eget arcu efficitur vulputate. Phasellus sed quam diam. Proin enim felis, luctus nec orci a, porta blandit tellus. Nulla ac erat suscipit, sagittis enim rutrum, scelerisque mi. Nullam vestibulum luctus lectus at cursus. Morbi ut orci lorem.
+
+Sed est justo, placerat id rhoncus eget, finibus vitae lectus. Aliquam ultricies porta nulla, eget aliquet ligula placerat a. Nulla suscipit laoreet elit. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc a arcu id nisi tincidunt ultrices vitae pharetra nisl. Quisque facilisis at dui vel dignissim. Etiam imperdiet in libero non venenatis. Vivamus consectetur lectus non ultricies laoreet. Aenean vel laoreet lectus, et laoreet tellus. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Etiam ex arcu, consequat eu diam non, tristique faucibus purus. Duis nisi elit, bibendum quis lacinia ac, fermentum a lorem. Suspendisse molestie nulla sed velit accumsan lobortis. Aliquam erat volutpat. In pharetra ultricies urna aliquet congue.
+
+Quisque ante metus, maximus et dui eget, sollicitudin accumsan risus. Ut malesuada neque et ex facilisis, sed egestas augue pellentesque. Suspendisse potenti. Nunc sapien libero, maximus vitae purus eu, lobortis sagittis diam. Aliquam ultricies vehicula lorem, sit amet vehicula dolor venenatis vitae. Phasellus consequat nisi ut quam tincidunt, eu bibendum nisi bibendum. Vivamus a interdum sapien. Vestibulum interdum pharetra molestie. Sed facilisis dui non velit malesuada, semper rhoncus sapien volutpat. Etiam arcu nisl, dignissim sit amet purus non, tempus finibus orci. Pellentesque viverra faucibus enim, eget dignissim justo accumsan ac. Quisque pellentesque orci nisl, in vestibulum massa auctor a.
+
+Pellentesque condimentum odio in turpis mattis, ac blandit dui commodo. Sed consectetur purus sit amet quam dapibus placerat nec ut orci. Maecenas mollis ex in mi commodo sodales. Sed est enim, consequat dapibus convallis quis, iaculis non dolor. Donec sagittis fermentum velit ut convallis. Nunc accumsan mi vel enim consequat commodo. Nunc varius id massa nec consequat. Donec purus sem, pellentesque gravida mollis ac, convallis a tellus. Praesent convallis massa lacus, eget pellentesque neque sodales nec. Sed ut velit diam. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Suspendisse lacus erat, mattis eu tellus sit amet, vehicula bibendum mi. Nam aliquam, nisi dapibus condimentum congue, ante mauris bibendum turpis, a consequat risus arcu eget felis. Aenean dictum, nisi in facilisis sollicitudin, felis diam convallis magna, eu pulvinar nisl odio quis massa. Suspendisse imperdiet tincidunt tortor, sit amet dignissim augue eleifend a. Vivamus consequat mauris vel tellus ullamcorper, in mattis ex auctor.
+
+Donec eros nunc, maximus non faucibus id, malesuada nec dui. Mauris rutrum accumsan nisi, volutpat tristique justo vulputate posuere. Vestibulum iaculis neque ut sapien sagittis, et volutpat erat finibus. Maecenas volutpat varius orci, ac lobortis justo fermentum vel. Ut nec tortor non erat sagittis dignissim at sed nunc. Sed porttitor dapibus velit a pretium. Proin id placerat magna, fringilla volutpat diam. Cras non ipsum non est porttitor fringilla eget sit amet turpis. Vestibulum vel pharetra nulla. Praesent ultricies mi urna, eget aliquam augue feugiat eu. Aenean efficitur ex ut luctus facilisis. Fusce leo odio, suscipit eget est eget, pretium posuere mauris. Fusce vulputate est sed felis mattis, at sollicitudin magna consequat. Aliquam erat volutpat. Mauris tincidunt tristique diam id tincidunt. Aenean sagittis dictum risus.
+
+Nunc vehicula mattis justo at placerat. Duis ultrices metus urna, et mollis erat blandit non. Pellentesque tincidunt vitae mi eget placerat. Nullam at condimentum arcu. Vestibulum sit amet orci et metus fringilla pretium ac ut magna. Suspendisse vitae accumsan orci. Donec convallis nunc odio, tincidunt volutpat tellus placerat ac. Phasellus sed bibendum eros, a auctor quam.
+
+Etiam sagittis accumsan sem ut interdum. Nullam eleifend eget felis in convallis. Donec sagittis enim interdum, suscipit metus ut, cursus orci. Integer vitae dapibus enim. Integer venenatis ligula ut lacus pretium, a pharetra massa posuere. Vivamus eu volutpat ipsum. Mauris tempus volutpat aliquet. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean ac odio bibendum, dictum neque sed, sollicitudin nulla.
+
+Quisque vulputate at ligula ut placerat. Morbi mollis ante id felis tempus consequat. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Maecenas eleifend odio a lectus sagittis, nec tristique ante egestas. Ut tempor, libero vel mattis interdum, risus quam condimentum turpis, nec viverra massa arcu ut turpis. Duis pharetra vehicula ligula, rhoncus commodo elit rutrum non. Nullam leo nisi, semper quis risus et, faucibus viverra odio.
+
+Quisque luctus nec arcu ut aliquam. Phasellus commodo ligula ut aliquet accumsan. Cras ac erat ac purus varius convallis. Vivamus nec gravida ipsum. Fusce euismod, massa ut cursus laoreet, eros urna semper odio, sed cursus turpis massa non lectus. Proin ac nisl lobortis, placerat elit in, placerat turpis. Nulla sollicitudin dolor ut sagittis consequat. Aenean augue felis, condimentum nec fermentum at, condimentum non nulla. Quisque et dignissim sapien, ac tincidunt elit. Nunc aliquet lacus id quam placerat suscipit. Mauris rutrum facilisis ipsum, at tristique mi. Sed iaculis eros sem, ut eleifend arcu hendrerit et. Sed euismod dignissim diam interdum ultrices. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed lobortis massa vel ultricies feugiat. Aenean non lobortis erat.
+
+Aenean commodo euismod massa vitae accumsan. Vivamus ac tristique mauris. Nunc hendrerit sapien a dictum scelerisque. Interdum et malesuada fames ac ante ipsum primis in faucibus. Quisque sit amet eleifend nulla, vel posuere lorem. Phasellus eu porta metus. Pellentesque eget sollicitudin dui, sed commodo magna. Integer tincidunt, diam vitae dapibus tincidunt, diam lorem rutrum erat, ut consequat ex metus sed leo.
+
+Suspendisse odio metus, suscipit at congue at, consectetur auctor justo. Integer vel rutrum lacus. Quisque a ullamcorper ligula, nec placerat arcu. Ut hendrerit orci sit amet leo pellentesque iaculis. Integer neque erat, dapibus vel pharetra ut, sagittis id diam. Duis eget ex felis. Donec eget odio in sem hendrerit varius. Sed malesuada euismod erat. Sed bibendum malesuada lacus at euismod. Ut ornare pretium imperdiet. Maecenas ut orci id massa lobortis pulvinar vitae et neque. Nullam iaculis dictum sagittis. Vivamus vel finibus libero, eget congue ligula. Etiam faucibus orci felis, eu accumsan enim sollicitudin at. Donec accumsan libero at pharetra malesuada.
+
+Nullam luctus, metus eu varius dignissim, lectus neque aliquet massa, nec pellentesque ligula ligula vel leo. Cras rutrum eleifend viverra. Sed lobortis eget erat tincidunt imperdiet. Nullam ac fringilla urna. Fusce pretium, lorem ac mollis semper, sem felis ornare odio, eget feugiat dolor orci ut dui. Curabitur ac odio mollis, convallis ex eget, hendrerit nulla. Nunc vel turpis nisl. Ut neque urna, fermentum interdum est non, lobortis luctus elit. Phasellus bibendum malesuada gravida. Phasellus lacinia scelerisque erat sit amet iaculis. Nulla in ultricies lectus.
+
+Praesent blandit ante congue urna eleifend porta. Nulla sagittis urna quis molestie viverra. Praesent in lorem porttitor, vestibulum orci hendrerit, faucibus enim. Donec sapien enim, porta at sapien eget, condimentum mattis dui. Aliquam rhoncus dui elit, non laoreet ex condimentum ut. Nam arcu sem, suscipit quis diam vel, pharetra bibendum ligula. Duis vel ipsum gravida libero iaculis feugiat. Aliquam congue augue mi, gravida dignissim ipsum commodo id.
+
+Suspendisse vel tincidunt odio. Donec quis hendrerit felis, sed sagittis mi. Cras ultricies justo et ligula dignissim, ac porta nisi maximus. Suspendisse vitae facilisis sapien, ut consequat lacus. Morbi dapibus in diam in tempus. Curabitur viverra leo libero, et molestie lacus interdum eu. Donec ut odio sit amet nisl viverra fermentum eget eget sem. Donec id ante consectetur, porta velit a, consectetur mauris. Donec imperdiet dolor turpis, at maximus purus volutpat ac. Ut hendrerit eros sit amet mi porttitor, nec ultrices purus posuere. Etiam elementum mauris ligula, nec viverra neque luctus quis.
+
+Donec ultrices lectus nec sollicitudin egestas. Mauris ac lacinia mauris. Proin accumsan leo et quam venenatis mattis. Pellentesque laoreet interdum feugiat. Phasellus arcu justo, blandit vel faucibus vel, maximus in sapien. Mauris semper, leo quis accumsan tristique, arcu massa tempus sapien, nec luctus turpis mi id enim. Donec egestas consectetur augue non viverra. Mauris pellentesque turpis non ante posuere, bibendum laoreet nunc semper. Aliquam accumsan semper nulla, sed tincidunt nulla pretium id. Mauris ut sapien vel felis pharetra congue. Curabitur ac euismod risus.
+
+Integer a lectus lorem. Phasellus a sodales odio. In consectetur bibendum ex eu blandit. Nam eu feugiat sapien, id efficitur orci. Quisque fermentum sem eget orci mattis tristique. Donec sit amet pharetra massa. Pellentesque molestie, neque a viverra dignissim, magna quam sagittis ligula, at tincidunt tellus risus quis enim. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Praesent scelerisque faucibus nunc eget consequat. Fusce aliquet egestas eros quis auctor.
+
+Sed aliquam mauris non lacus rhoncus, id eleifend nunc ullamcorper. Nulla cursus erat non purus gravida, porta ultricies libero vestibulum. Nulla sagittis metus eleifend porttitor molestie. Suspendisse rutrum consequat ullamcorper. Ut pellentesque dolor eget gravida cursus. In posuere, ipsum nec pulvinar varius, massa odio aliquam mauris, vitae facilisis ligula orci quis augue. Pellentesque a tortor ultricies, ullamcorper libero ut, ullamcorper augue. Nullam id felis non dui viverra placerat id eu metus. Aenean ac dui condimentum, dapibus tellus non, blandit ex. Maecenas et odio vitae massa gravida consequat eu sed nunc. Nullam laoreet, nisi sed imperdiet laoreet, sapien nisl aliquam augue, vitae ornare velit ligula id neque. Ut tincidunt, lacus at porta ultricies, tellus felis fringilla dolor, tempus posuere nibh nisi eu felis. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae;
+
+Proin ac nulla turpis. Aenean pretium congue viverra. Donec vitae sem venenatis, luctus lacus non, rhoncus purus. Etiam sit amet lorem consequat, mollis nibh quis, congue neque. Sed vulputate justo quis porttitor malesuada. Nullam id ex sit amet ante aliquet tincidunt. Praesent pretium maximus orci ut cursus.
+
+Mauris vitae aliquam magna. Sed quis ante cursus, dapibus risus vel, tristique nisi. Fusce suscipit porta quam, vel vestibulum ligula dapibus vel. Nunc consequat eu mi at aliquam. Donec sit amet dolor nulla. Praesent gravida tellus enim, in porttitor sem scelerisque vitae. Nullam consequat, nunc eu iaculis tempor, sem augue placerat ex, sed ultrices erat nisi a tellus. Nunc tortor nisl, feugiat lobortis rutrum ut, pharetra ac nulla. Donec eu tortor eros. Proin maximus nisl sit amet velit accumsan facilisis. Praesent posuere tristique faucibus. Vivamus nec hendrerit tellus, id vulputate eros. Aliquam a lacus efficitur, consectetur ipsum eu, ullamcorper ex. Aliquam erat volutpat.
+
+Vivamus ultrices scelerisque elit, ac ultrices erat consequat id. Sed ac aliquet nulla. Pellentesque vel justo magna. Suspendisse dictum, sem eget ullamcorper iaculis, sapien metus tristique mauris, et dictum elit eros sit amet ex. Mauris placerat odio eu ligula egestas sagittis. Integer vel turpis lacinia tortor molestie egestas et id dui. Donec porta interdum justo, ac ornare lacus dictum at. Quisque mollis, odio sed eleifend rhoncus, purus turpis fringilla quam, ac fermentum enim ante sed massa.
+
+Vestibulum neque ipsum, congue vel lacus et, faucibus mattis sem. Ut venenatis, tortor non tincidunt mollis, sapien leo suscipit dolor, posuere tristique libero massa eu augue. Donec eu luctus velit. Nulla egestas, tellus sed commodo gravida, metus nibh placerat sem, nec mollis nulla nunc id lorem. Nulla facilisi. Donec ut tincidunt sapien. Quisque dapibus convallis interdum. Nulla tempor malesuada turpis non vehicula. In nec tortor ultrices, vestibulum odio non, ultrices sapien. Pellentesque mattis feugiat arcu, id tincidunt leo malesuada at. Fusce vitae pretium ante. Pellentesque eu augue non lectus efficitur rutrum. Cras vitae nisl elementum, congue est eget, faucibus quam. Donec in dapibus metus.
+
+In imperdiet metus eget leo rhoncus, et pharetra dui laoreet. Morbi arcu augue, eleifend a est eget, gravida suscipit risus. Ut sodales ex vel eleifend bibendum. Nam varius nisl sit amet dolor porta pulvinar. Ut mollis purus sit amet tempus vulputate. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Curabitur a lacinia velit, in feugiat elit. Sed ut vestibulum lorem. Proin fermentum elit quis venenatis placerat. Cras sit amet congue tortor. Curabitur eget sapien massa. Suspendisse in turpis arcu.
+
+Quisque vitae risus scelerisque, rutrum tellus et, posuere massa. Vestibulum vitae rhoncus libero, vel ultrices elit. Vivamus nec ipsum ac urna tristique sollicitudin non nec tellus. Donec bibendum dui eget ipsum laoreet, sed tincidunt tellus laoreet. Proin in rhoncus nibh. Integer vel quam id felis interdum aliquet. Nulla tempus volutpat consequat. Suspendisse nec massa malesuada, finibus est non, eleifend odio. Aliquam libero turpis, consequat vel pellentesque vitae, laoreet vitae tellus. Donec finibus diam id accumsan luctus.
+
+Cras at lorem ligula. Praesent tincidunt justo eu purus suscipit ornare. Morbi malesuada dui non ligula congue, ac fringilla diam commodo. Proin vel arcu non tortor tempus lacinia eget ut arcu. Sed tristique lorem et purus tristique, nec ultrices tortor lacinia. Nunc id nibh id mauris volutpat rutrum at in nisl. Cras in cursus lectus, nec fermentum dolor. Morbi at tempus tortor. Aenean pulvinar ex erat, vitae aliquet nisl finibus at. Praesent pellentesque tempor imperdiet. Aliquam eu aliquet purus. Maecenas hendrerit volutpat ultrices. Aliquam metus tellus, porttitor sit amet sem ut, bibendum ultricies urna.
+
+Cras accumsan lacus ac ullamcorper tincidunt. Fusce imperdiet nunc vel diam condimentum, viverra dignissim magna mollis. Aliquam rutrum gravida libero non congue. Morbi pretium, nulla ac eleifend sodales, dolor orci feugiat ipsum, ut posuere dolor augue quis mauris. Cras tincidunt enim dui, at porta orci consectetur vel. In id purus ante. Donec luctus mattis dictum. Curabitur tortor orci, accumsan finibus sodales ac, maximus eget purus. Suspendisse efficitur vitae dui ut faucibus. Integer bibendum ipsum massa, sagittis posuere sapien elementum at. Vivamus tristique at quam id congue. Maecenas eu augue vel erat varius congue at id quam.
+
+Sed tristique nisl elit, finibus venenatis urna facilisis id. Integer cursus interdum justo, et viverra diam interdum quis. Sed in vestibulum arcu. Pellentesque elementum ex vitae diam tincidunt bibendum. Nunc eu mi suscipit, faucibus metus sit amet, tincidunt dolor. Integer vulputate sodales luctus. In ut scelerisque sem, sed egestas eros. Etiam lobortis diam ac augue pulvinar, eu aliquam massa blandit.
+
+In dui magna, faucibus at purus in, sagittis dapibus diam. Cras commodo massa tortor, eu consequat libero placerat eu. Ut mauris metus, facilisis et erat sed, rhoncus maximus nisl. Sed ac aliquet nisi. Aenean in rhoncus velit. Sed mollis, nunc vitae imperdiet pharetra, arcu ex pulvinar nibh, ac rhoncus lectus enim nec erat. Donec rutrum molestie nibh et lobortis. Proin nec nibh in ex pretium ultrices non et arcu. Nam consequat tempor viverra. Fusce vitae pharetra diam, ac bibendum ex. Quisque cursus, tellus ac interdum accumsan, lectus nunc lobortis elit, id varius orci diam a metus. Etiam at mauris vitae metus ullamcorper bibendum nec sed leo. Pellentesque eu arcu varius, imperdiet ligula non, maximus tellus. Aliquam erat volutpat.
+
+Curabitur fringilla ligula in consectetur varius. Donec eget tortor ex. Nunc quis lacus lobortis, vulputate lorem eu, scelerisque sapien. Aliquam non pretium ante. Aenean maximus ornare eros, ut condimentum nibh pulvinar eu. Morbi venenatis sollicitudin justo, non tincidunt ligula lacinia vitae. Nam vitae quam ligula. Fusce in finibus urna, a laoreet dui. Quisque urna arcu, aliquam sed dolor quis, pellentesque convallis risus. Vestibulum faucibus maximus justo, eget gravida elit tincidunt quis. Cras in arcu dui. Aliquam eu nibh gravida, lacinia ipsum sit amet, scelerisque nisl. Integer luctus sagittis mattis. Etiam dolor sapien, dapibus at neque nec, rhoncus scelerisque odio. Pellentesque laoreet justo ac augue eleifend placerat. In vitae hendrerit ex.
+
+Nam sit amet dui in libero volutpat lacinia. Quisque vel luctus purus. Aenean arcu magna, luctus sed interdum vitae, elementum quis eros. Mauris aliquet diam mi, ut tincidunt magna consequat quis. Cras vitae lacus posuere urna pretium lacinia. Fusce ultricies maximus hendrerit. Donec et augue quis lectus lacinia accumsan. Nunc tortor neque, vestibulum porta bibendum id, varius quis sapien. Vestibulum et ultricies odio, id pharetra lacus. Suspendisse sollicitudin nisl nec justo fermentum, vitae volutpat lectus aliquam. Duis blandit quam at erat sodales, ut suscipit erat aliquet. Fusce faucibus dui enim, eu varius neque imperdiet id. Vestibulum dapibus neque libero, vitae viverra erat mattis id. Quisque ullamcorper diam ut porta finibus. Donec faucibus, diam quis pellentesque euismod, enim velit mattis justo, at ultricies urna enim ac leo.
+
+Fusce fringilla dolor sit amet ante pharetra ornare. Aliquam erat volutpat. Donec laoreet, lorem nec pulvinar ullamcorper, urna justo bibendum nunc, in laoreet nisl tortor vel justo. Donec a magna molestie, gravida tortor a, malesuada tortor. Praesent vestibulum ultricies metus, vitae fringilla tellus viverra sed. Suspendisse sed odio sit amet nibh ultricies interdum accumsan egestas ex. Fusce ac lacus arcu. Ut ultricies at justo elementum mattis. Nullam augue tortor, lacinia tempor turpis a, porta finibus neque. Donec id diam tristique arcu vestibulum fermentum vitae id tellus. Vestibulum sit amet ligula neque. Aliquam neque ante, ultricies nec diam malesuada, feugiat consequat risus. Pellentesque ac varius orci.
+
+Etiam nunc ex, laoreet eget eros ut, ultricies fermentum sem. Nullam venenatis diam a lectus vulputate luctus. Integer laoreet libero et tellus fermentum, ut maximus neque tristique. Ut in odio posuere, lobortis augue non, tristique orci. Quisque vel ultricies mauris, non consectetur enim. Sed dictum vitae felis vel scelerisque. Vestibulum id viverra leo. Etiam libero neque, cursus eu augue eget, fringilla luctus arcu. Donec aliquet maximus ipsum, ut faucibus velit posuere non. Praesent finibus erat nec massa cursus, ac blandit ante bibendum. Ut vel magna pretium, interdum quam non, sodales erat.
+
+Sed et orci nunc. Vestibulum elit sem, dapibus id dictum eu, interdum sit amet justo. Morbi interdum hendrerit tempus. Quisque id magna justo. Donec sollicitudin, nunc a efficitur hendrerit, mi neque semper nisl, sed consectetur urna justo vel velit. Nullam at sodales eros. Donec eu nunc vel dui tristique blandit ut eget enim.
+
+Nulla velit neque, euismod vitae lectus vel, finibus egestas magna. Ut sed justo sed erat pretium sollicitudin nec nec felis. In mattis augue ut erat mollis, in posuere purus tincidunt. Vivamus rhoncus sem at purus gravida, et vestibulum justo elementum. Aenean sit amet elit ac ligula tincidunt varius. Donec feugiat, orci vel interdum lobortis, elit magna fringilla nulla, non euismod urna dolor auctor est. Mauris laoreet sagittis ligula, et semper nisi finibus et. Donec pharetra nibh in eros iaculis aliquam. Nam malesuada ornare elit, ac semper massa molestie sed. Maecenas laoreet diam eu ipsum rutrum, ut varius enim bibendum. Donec luctus dolor eu ipsum varius, malesuada condimentum sapien tempor.
+
+Aenean vel rhoncus lacus, sit amet faucibus nisl. Aliquam laoreet nisl et diam eleifend molestie non vel lectus. Duis tortor augue, congue luctus malesuada sit amet, posuere mattis mauris. Aliquam quis ligula ut ipsum placerat luctus. Aliquam accumsan mauris ligula. Sed quis lacinia augue. Proin feugiat diam lectus, vel elementum libero varius non. Proin porta neque sed dolor gravida venenatis. Donec vitae euismod nibh. Morbi mattis, enim quis mattis dignissim, lacus tellus tristique nisl, in luctus leo nisl vel elit. Sed posuere justo in iaculis mattis.
+
+Curabitur in felis et metus blandit auctor ac in nulla. Vestibulum dictum nulla posuere augue ultrices, non gravida velit placerat. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. In malesuada pharetra ante sit amet sodales. Suspendisse et tincidunt lorem. Interdum et malesuada fames ac ante ipsum primis in faucibus. Integer viverra justo ut nisi elementum dictum. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Nullam dictum tincidunt venenatis. Aliquam neque urna, pellentesque vitae ultrices eget, lobortis sed augue. Etiam at ex ultricies, egestas dui sit amet, laoreet lorem. Ut nulla velit, bibendum in arcu sed, dignissim mattis odio. Suspendisse varius dictum vulputate. Sed nisl tellus, eleifend quis augue ac, malesuada elementum arcu.
+
+Morbi dignissim laoreet imperdiet. Vivamus tincidunt turpis quis posuere mattis. Nam mollis, elit eget lacinia auctor, lorem magna mattis elit, eget pulvinar mauris quam sed turpis. Suspendisse nibh libero, volutpat nec metus tempus, euismod lobortis sapien. Pellentesque interdum urna a leo dignissim lobortis. Suspendisse quis diam pretium, vehicula augue eget, sodales nibh. Cras dignissim lorem ac velit mollis, ac hendrerit urna varius. Fusce venenatis elit ut mauris volutpat, sed imperdiet arcu pellentesque.
+
+Phasellus auctor nec ex eu tempor. Quisque ut elit eget ligula euismod pretium. Quisque ac lectus et est fringilla convallis. Mauris tincidunt turpis non ullamcorper suscipit. Suspendisse consectetur lacus at lacinia iaculis. Morbi purus metus, tincidunt ac ultricies a, rhoncus varius magna. Suspendisse mattis vehicula enim at ultrices. Phasellus eu ipsum nisi. Duis dignissim massa non convallis rutrum. Sed placerat consectetur ex, quis malesuada lectus cursus a. Nulla non mi egestas, scelerisque urna vitae, pulvinar libero. Vestibulum pretium purus at odio pharetra, ut egestas nibh pretium.
+
+Nulla facilisi. Duis in augue eu elit accumsan imperdiet a a odio. Curabitur vitae ante in velit condimentum venenatis id vitae mi. Sed in ante fringilla, mollis metus vel, consectetur nisi. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nulla non dolor congue neque dapibus varius. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Aliquam sit amet convallis velit. Praesent a efficitur massa, non finibus ex. Maecenas pharetra elit eget sem rhoncus, vel mollis eros pretium. Donec vehicula dolor a nulla ornare, at lacinia ex venenatis.
+
+Suspendisse aliquam blandit est, rutrum luctus turpis cursus vitae. Pellentesque in magna eget risus egestas rhoncus. Maecenas sed odio non ex interdum eleifend mollis convallis neque. Quisque a orci fringilla, maximus arcu id, rhoncus magna. Aenean at aliquam est. Aenean faucibus consequat tempus. Aliquam congue viverra ante, non aliquet sapien viverra ac. Etiam ullamcorper neque in metus malesuada suscipit. Curabitur quis placerat mi.
+
+Integer at mauris ut lacus vulputate mattis sit amet at purus. Proin arcu nisl, lacinia eu venenatis ac, mattis ut velit. Suspendisse elementum mattis mauris, in faucibus lorem. Suspendisse bibendum nulla in commodo ultrices. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Vivamus iaculis volutpat mattis. Pellentesque ut ex interdum, consequat diam egestas, blandit nisi.
+
+Nullam odio turpis, pretium ac ante porttitor, fringilla lacinia ante. Fusce commodo quam vel dui blandit, nec eleifend tellus aliquam. Fusce sodales efficitur urna, vitae vehicula erat lacinia eu. Praesent maximus nunc id sapien feugiat, in euismod nibh rutrum. Vivamus at volutpat libero. Praesent quis mattis mi. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. In hac habitasse platea dictumst. Integer quam odio, pharetra nec molestie porttitor, auctor at ligula. Fusce id turpis non tellus facilisis tincidunt.
+
+Morbi lorem risus, sagittis sit amet venenatis sit amet, lacinia at dui. Vestibulum volutpat, urna ac ultrices efficitur, tortor augue convallis dolor, nec commodo arcu arcu id ante. Quisque facilisis mauris in molestie tincidunt. Fusce aliquet sagittis interdum. Vivamus sit amet odio nec augue volutpat placerat non nec nibh. Nunc auctor purus eu dignissim euismod. Ut sollicitudin urna et erat placerat, vel accumsan lectus malesuada. Proin fringilla magna sit amet massa dignissim lobortis ut ac felis. Donec ornare dignissim tristique. Phasellus semper, est sit amet vestibulum suscipit, arcu est elementum nulla, in sagittis sapien ligula a sem.
+
+Morbi at justo molestie, gravida lacus quis, placerat est. Mauris non libero ultricies, convallis dui et, scelerisque est. Nunc iaculis, libero sed ullamcorper feugiat, eros ante lacinia ex, vel efficitur velit arcu eu metus. Quisque fermentum blandit fermentum. Vestibulum quis ante in dolor porta efficitur eu nec libero. Mauris vitae ex mattis mi fringilla pharetra. Donec eget est nec lorem pretium pretium. Fusce eget risus eros. Vivamus eu nulla et libero tincidunt malesuada at ac dolor. Donec facilisis tempus sem, in posuere orci sagittis vel. Donec pellentesque sapien mi, eu tempus enim tempor vel. Cras consequat purus sed ornare vehicula. Nunc molestie eu ex et fermentum. In vestibulum, arcu nec cursus efficitur, leo ex fringilla neque, in molestie nisl diam mattis sapien. Nunc et semper ante.
+
+Sed pellentesque laoreet sollicitudin. Ut sed ex eu sapien bibendum posuere. Mauris non sem dui. Fusce sit amet nulla a tortor blandit blandit. Proin venenatis ligula quis sapien viverra accumsan. Proin ac turpis a dolor rhoncus facilisis eget vel ipsum. In gravida porttitor quam, quis dignissim lacus laoreet porta. Nulla ante risus, luctus at pharetra vitae, vehicula id elit. Etiam sagittis dui vitae metus mollis, in porttitor elit fringilla. Duis dapibus dignissim faucibus. Duis elementum facilisis leo eget ornare. Cras feugiat libero at efficitur tempus. Suspendisse sit amet laoreet nunc, at faucibus tellus. Vestibulum in ipsum ac risus vehicula porta. Fusce maximus libero mattis risus aliquam condimentum. Fusce ut consectetur risus, a fermentum arcu.
+
+Curabitur hendrerit eu lacus non congue. Fusce ac dictum magna. Nulla elit ante, sodales sed lobortis sodales, fermentum vitae urna. Cras pharetra vel sapien dignissim ullamcorper. Phasellus auctor elementum suscipit. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec lacus odio, venenatis lobortis ullamcorper et, tempor nec augue.
+
+Mauris scelerisque vestibulum metus, vitae porta sem pharetra nec. Nam tempus dolor sed turpis lobortis sodales. Vestibulum nec mauris auctor velit pellentesque vestibulum tristique vel eros. Vivamus vel justo vel dui lobortis dapibus a at sapien. Maecenas ac metus nec tortor vulputate laoreet in nec augue. Aliquam tellus leo, imperdiet non dapibus a, facilisis non tellus. Suspendisse condimentum tincidunt lacus, ut scelerisque diam viverra nec. Etiam ante mauris, viverra sit amet vulputate ut, porta a ligula. Donec sit amet luctus massa. Morbi iaculis, tortor sit amet ullamcorper iaculis, mauris augue feugiat risus, eu bibendum dui tellus nec purus. In gravida sodales egestas. Sed tincidunt pellentesque tincidunt. In non neque non erat mattis iaculis. Cras et ipsum justo. Phasellus ex elit, dictum ut nulla et, consectetur auctor lectus.
+
+Donec vitae velit nisi. Cras lobortis a nisi eu molestie. Nunc mattis arcu id neque aliquam, quis sollicitudin lectus lobortis. Donec nec convallis purus, eget sagittis sapien. Maecenas viverra ullamcorper quam in vehicula. Pellentesque imperdiet nisl in elit varius, eu fringilla orci ullamcorper. Donec blandit ultrices volutpat. Nulla nec tempor mi, ac finibus nisl. Phasellus et urna non lorem tincidunt pulvinar nec nec ligula. Ut hendrerit volutpat diam. Morbi vel sollicitudin libero, ac molestie purus. Nulla sit amet metus ut leo molestie faucibus. Nunc porttitor, est in pulvinar vestibulum, justo nibh placerat ipsum, at interdum metus mi vitae dui. Curabitur in egestas nunc. Ut malesuada ipsum sed velit rutrum accumsan ac in quam.
+
+Quisque ex est, fermentum vitae placerat sit amet, porta ac nulla. Morbi accumsan tellus quis dolor cursus, in elementum sapien condimentum. In non dui ultrices, sagittis dui quis, blandit nunc. Curabitur blandit justo sed tincidunt imperdiet. Sed a odio aliquet, gravida augue non, faucibus magna. Phasellus pulvinar volutpat sem, ut bibendum nibh semper eu. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Curabitur at tellus in nulla vulputate feugiat vitae id dui. Suspendisse nec velit ac arcu fringilla venenatis. Duis urna massa, eleifend sit amet venenatis in, lobortis ac odio. Aliquam blandit vitae ipsum quis tempor. Curabitur a interdum sapien, vitae tempus arcu. Maecenas condimentum, justo vel rhoncus facilisis, lectus nisl commodo massa, eget maximus odio enim sit amet libero. Morbi at erat purus. Aenean dictum diam ut lorem venenatis consectetur. Praesent sit amet dolor eget lectus mollis tempus ac sit amet diam.
+
+Maecenas at convallis magna, nec iaculis metus. Quisque pulvinar ultricies vehicula. Aliquam quis tortor in elit semper tincidunt. Nullam aliquet ex dapibus lorem mattis gravida. Suspendisse volutpat, nibh sit amet efficitur egestas, lorem justo convallis enim, nec efficitur nunc mauris vel nisl. Sed condimentum ac justo sit amet accumsan. Suspendisse ultricies dolor nulla, at euismod nisl semper eu. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos.
+
+Donec hendrerit, ex non tincidunt molestie, lacus mauris euismod risus, vitae suscipit sem orci et risus. Donec sollicitudin eros non ante gravida aliquam. Etiam at augue risus. Mauris vitae ante ac eros sodales ornare non in enim. Fusce consequat tortor urna. Aenean condimentum neque quis viverra interdum. Aliquam ultricies convallis ipsum, nec lacinia massa bibendum nec. Suspendisse ac ultricies diam, sit amet mollis mi. Mauris at tincidunt elit. Morbi fringilla nisl ligula, nec scelerisque magna viverra non. Aliquam aliquam porttitor eros, cursus congue eros maximus vel.
+
+Pellentesque mattis sapien eu scelerisque feugiat. In hendrerit rutrum sem vel convallis. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Sed varius velit et erat lacinia ornare ut sed nibh. Nam imperdiet hendrerit urna, ultricies dapibus elit blandit sit amet. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aliquam porttitor, purus scelerisque ornare aliquam, massa nulla semper erat, sit amet cursus diam risus vitae mauris. Ut rhoncus pellentesque elementum.
+
+In a ipsum in dui venenatis scelerisque ut a ante. Quisque tincidunt turpis vitae arcu rhoncus, quis maximus nisl venenatis. Sed ac tortor et nibh aliquam posuere. Praesent ipsum tortor, scelerisque nec sem vitae, efficitur mollis lacus. Sed dui tellus, mattis eu turpis in, accumsan mattis elit. Donec eu nunc dolor. Ut ornare dui quis tortor hendrerit ornare. Sed finibus ornare nulla, vitae vehicula urna vestibulum at. Integer fermentum diam sit amet congue suscipit. Donec massa lectus, dignissim ut metus eu, vehicula dictum nisi.
+
+Phasellus ligula tortor, consequat a urna quis, interdum congue libero. Sed condimentum sapien sed gravida tristique. Suspendisse vel condimentum orci. Pellentesque pharetra hendrerit malesuada. Morbi commodo ut quam et iaculis. Ut finibus dapibus metus, ut varius orci dapibus non. Nunc efficitur efficitur ultricies. Sed laoreet quam vel volutpat laoreet. Nullam placerat suscipit neque at aliquet. Curabitur luctus nisi eget rutrum interdum. Nam lacinia turpis sed massa euismod tincidunt. Aenean odio nisi, hendrerit et lacus et, sodales mollis leo. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Donec posuere erat nibh, a tristique quam bibendum sed.
+
+Nulla vestibulum leo laoreet, mattis purus at, tempus dolor. Morbi nibh lacus, vehicula eu nibh vel, pellentesque pulvinar magna. Suspendisse urna lorem, pretium non lorem eu, maximus porttitor eros. Integer in purus consectetur, pretium massa ac, bibendum quam. Vivamus venenatis finibus feugiat. Donec ornare neque eu convallis varius. Nullam sodales, tortor id semper varius, nibh odio tincidunt mi, vitae gravida purus erat nec libero. Nam varius tincidunt maximus. Nunc quis metus a diam porta tincidunt ac quis ex. Nunc bibendum nisl tortor, interdum luctus augue suscipit et. Phasellus pretium egestas aliquam. Maecenas in libero enim.
+
+Duis lacinia dolor eu nunc viverra, quis blandit nunc posuere. Suspendisse ultricies ultrices tincidunt. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Proin imperdiet finibus dui, sed vehicula ligula semper vitae. Vestibulum elementum a ante quis vestibulum. Integer sit amet ullamcorper sapien. Cras sapien odio, commodo at consequat non, auctor volutpat ante. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Maecenas ut congue urna, eu iaculis lectus. Curabitur consequat, lectus non pharetra ultricies, massa sapien pellentesque lectus, eu laoreet elit turpis et sapien.
+
+Pellentesque vel vehicula arcu. Proin aliquam hendrerit turpis aliquam ultrices. Nunc pellentesque urna tempor ipsum porta faucibus. Morbi lobortis quam eget lacus tempor, tempor commodo justo molestie. Suspendisse cursus turpis diam, eget pulvinar velit dignissim ut. Donec vulputate sodales justo ac hendrerit. Donec ultricies mauris id lorem bibendum pulvinar. In sed dictum ex. Phasellus sit amet lacus eget risus scelerisque congue id vitae ex. Vestibulum pellentesque rhoncus lacus, non lobortis dui faucibus non. Cras efficitur dictum rutrum. Pellentesque euismod id felis sit amet faucibus. Maecenas tristique urna ac mi tristique, ac varius ante cursus.
+
+Vestibulum eu mi sed felis consequat fermentum. Duis sit amet nulla a diam maximus tristique. Sed in turpis diam. Cras sodales egestas massa. Maecenas eget dui tellus. Quisque vulputate tellus sem, non dictum nisi feugiat eget. Suspendisse interdum urna id quam facilisis tristique. Proin dolor ex, vestibulum quis dui ac, dignissim blandit dolor. Sed nec interdum ante. Nullam fermentum iaculis augue ut sodales. Mauris dapibus interdum maximus. Aliquam laoreet nisl et tellus congue, nec molestie justo hendrerit. Suspendisse eros libero, semper a nulla a, placerat convallis leo. Ut ornare turpis velit, id ultrices nulla lobortis non.
+
+In hac habitasse platea dictumst. Etiam condimentum, nunc vitae faucibus mattis, diam neque accumsan urna, eu tincidunt augue odio sit amet metus. Quisque at mauris eget purus ultricies ultricies vel eget ligula. Phasellus tortor urna, vestibulum eget tincidunt ut, malesuada nec ligula. Phasellus congue dignissim erat ut lacinia. Duis massa lacus, placerat quis ipsum sit amet, maximus ornare velit. Nulla commodo, urna maximus vehicula suscipit, arcu elit commodo leo, ut luctus mauris ipsum sit amet turpis. Donec ornare dignissim tincidunt. Duis efficitur tristique eros, bibendum mattis lorem auctor sit amet. Donec fermentum imperdiet venenatis. Praesent scelerisque purus in scelerisque dignissim. Nulla eu rhoncus nisl.
-Phasellus placerat elit eu fringilla pharetra. Vestibulum consectetur pulvinar nunc, vestibulum tincidunt felis rhoncus sit amet. Duis non dolor eleifend nibh luctus eleifend. Nunc urna odio, euismod sit amet feugiat ut, dapibus vel elit. Nulla est mauris, posuere eget enim cursus, vehicula viverra est. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque mattis, nisi quis consectetur semper, neque enim rhoncus dolor, ut aliquam leo orci sed dolor. Integer ullamcorper pulvinar turpis, a sollicitudin nunc posuere et. Nullam orci nibh, facilisis ac massa eu, bibendum bibendum sapien. Sed tincidunt nunc mauris, nec ullamcorper enim lacinia nec. Nulla dapibus sapien ut odio bibendum, tempus ornare sapien lacinia.
+Integer quis orci in nisl egestas porta vel efficitur ligula. Sed urna nibh, efficitur ac odio eget, rhoncus viverra magna. Nunc at luctus velit. Nullam laoreet, diam non semper faucibus, purus nisl sagittis mauris, in fringilla dolor sapien et massa. Duis rhoncus lectus nibh, in molestie ante consequat vitae. Fusce a enim vel justo posuere tempor. Interdum et malesuada fames ac ante ipsum primis in faucibus. Pellentesque eget mi id nulla tristique pellentesque. Aenean lacinia metus lacus, eu viverra turpis interdum at. Aliquam ut convallis mauris. Donec scelerisque ex nulla, id convallis magna vehicula auctor. Maecenas aliquam, felis dapibus convallis congue, odio nisl accumsan dui, vel molestie ex massa quis metus. Vestibulum id vulputate justo. Sed aliquet, est quis varius scelerisque, erat lorem mattis lorem, in sollicitudin risus lorem a justo. Praesent fermentum posuere turpis, vitae fermentum velit rhoncus ut.
-Duis ac hendrerit augue. Nullam porttitor feugiat finibus. Nam enim urna, maximus et ligula eu, aliquet convallis turpis. Vestibulum luctus quam in dictum efficitur. Vestibulum ac pulvinar ipsum. Vivamus consectetur augue nec tellus mollis, at iaculis magna efficitur. Nunc dictum convallis sem, at vehicula nulla accumsan non. Nullam blandit orci vel turpis convallis, mollis porttitor felis accumsan. Sed non posuere leo. Proin ultricies varius nulla at ultricies. Phasellus et pharetra justo. Quisque eu orci odio. Pellentesque pharetra tempor tempor. Aliquam ac nulla lorem. Sed dignissim ligula sit amet nibh fermentum facilisis.
+Quisque pellentesque urna vehicula est vestibulum blandit. Donec molestie sagittis erat, sed interdum est dignissim a. Fusce accumsan orci mauris, quis feugiat sem consequat sit amet. Nulla ultricies euismod molestie. Proin eleifend sodales diam vitae facilisis. Nullam sit amet urna tortor. Sed laoreet sapien eu quam cursus eleifend. Praesent vulputate metus turpis, quis aliquam enim semper ut. Donec dignissim libero quis magna euismod faucibus. Nulla aliquam ante id enim consectetur placerat.
-Donec facilisis rhoncus ante. Duis nec nisi et dolor congue semper vel id ligula. Mauris non eleifend libero, et sodales urna. Nullam pharetra gravida velit non mollis. Integer vel ultrices libero, at ultrices magna. Duis semper risus a leo vulputate consectetur. Cras sit amet convallis sapien. Sed blandit, felis et porttitor fringilla, urna tellus commodo metus, at pharetra nibh urna sed sem. Nam ex dui, posuere id mi et, egestas tincidunt est. Nullam elementum pulvinar diam in maximus. Maecenas vel augue vitae nunc consectetur vestibulum in aliquet lacus. Nullam nec lectus dapibus, dictum nisi nec, congue quam. Suspendisse mollis vel diam nec dapibus. Mauris neque justo, scelerisque et suscipit non, imperdiet eget leo. Vestibulum leo turpis, dapibus ac lorem a, mollis pulvinar quam.
+Fusce ullamcorper tellus id pulvinar dignissim. Nam sagittis luctus ipsum, non dictum urna pulvinar quis. Nunc hendrerit quam eu dui egestas, vitae semper sem vestibulum. In efficitur ligula ante, nec faucibus libero tristique ac. Suspendisse potenti. Ut vestibulum massa erat. Proin ornare mi et est varius, in fringilla mi laoreet. Sed libero nisi, gravida sed felis sit amet, bibendum semper risus. Curabitur luctus nunc vulputate elementum cursus.
-Sed sed mauris a neque dignissim aliquet. Aliquam congue gravida velit in efficitur. Integer elementum feugiat est, ac lacinia libero bibendum sed. Sed vestibulum suscipit dignissim. Nunc scelerisque, turpis quis varius tristique, enim lacus vehicula lacus, id vestibulum velit erat eu odio. Donec tincidunt nunc sit amet sapien varius ornare. Phasellus semper venenatis ligula eget euismod. Mauris sodales massa tempor, cursus velit a, feugiat neque. Sed odio justo, rhoncus eu fermentum non, tristique a quam. In vehicula in tortor nec iaculis. Cras ligula sem, sollicitudin at nulla eget, placerat lacinia massa. Mauris tempus quam sit amet leo efficitur egestas. Proin iaculis, velit in blandit egestas, felis odio sollicitudin ipsum, eget interdum leo odio tempor nisi. Curabitur sed mauris id turpis tempor finibus ut mollis lectus. Curabitur neque libero, aliquam facilisis lobortis eget, posuere in augue. In sodales urna sit amet elit euismod rhoncus.`
+Aliquam feugiat, est sed congue fermentum, nibh dolor suscipit nunc, sed porttitor velit dui quis eros. Nam aliquet neque sed faucibus sagittis. Ut iaculis dictum odio in vestibulum.`
diff --git a/fileTransfer/params.go b/fileTransfer/params.go
index 8e54d5d02c9430224f526008d9138cb35e08e1ce..fd756a6c8f1318df7200ee149ce17e24457dfe34 100644
--- a/fileTransfer/params.go
+++ b/fileTransfer/params.go
@@ -9,6 +9,7 @@ package fileTransfer
import (
"encoding/json"
+ "gitlab.com/elixxir/client/cmix"
"time"
)
@@ -20,19 +21,23 @@ const (
// Params contains parameters used for file transfer.
type Params struct {
// MaxThroughput is the maximum data transfer speed to send file parts (in
- // bytes per second)
+ // bytes per second). If set to 0, rate limiting will be disabled.
MaxThroughput int
// SendTimeout is the duration, in nanoseconds, before sending on a round
// times out. It is recommended that SendTimeout is not changed from its
// default.
SendTimeout time.Duration
+
+ // Cmix are the parameters used when sending a cMix message.
+ Cmix cmix.CMIXParams
}
// paramsDisk will be the marshal-able and umarshal-able object.
type paramsDisk struct {
MaxThroughput int
SendTimeout time.Duration
+ Cmix cmix.CMIXParams
}
// DefaultParams returns a Params object filled with the default values.
@@ -40,6 +45,7 @@ func DefaultParams() Params {
return Params{
MaxThroughput: defaultMaxThroughput,
SendTimeout: defaultSendTimeout,
+ Cmix: cmix.GetDefaultCMIXParams(),
}
}
@@ -61,9 +67,11 @@ func (p Params) MarshalJSON() ([]byte, error) {
pDisk := paramsDisk{
MaxThroughput: p.MaxThroughput,
SendTimeout: p.SendTimeout,
+ Cmix: p.Cmix,
}
return json.Marshal(&pDisk)
+
}
// UnmarshalJSON adheres to the json.Unmarshaler interface.
@@ -77,6 +85,7 @@ func (p *Params) UnmarshalJSON(data []byte) error {
*p = Params{
MaxThroughput: pDisk.MaxThroughput,
SendTimeout: pDisk.SendTimeout,
+ Cmix: pDisk.Cmix,
}
return nil
diff --git a/fileTransfer/params_test.go b/fileTransfer/params_test.go
index b60676c994610796744fe326bce6cff09775abc4..c7015a44933dafce6abd75b4f161ba165ae490a5 100644
--- a/fileTransfer/params_test.go
+++ b/fileTransfer/params_test.go
@@ -8,17 +8,60 @@
package fileTransfer
import (
+ "bytes"
+ "encoding/json"
+ "gitlab.com/elixxir/client/cmix"
"reflect"
"testing"
)
+// Tests that no data is lost when marshaling and
+// unmarshaling the Params object.
+func TestParams_MarshalUnmarshal(t *testing.T) {
+ // Construct a set of params
+ p := DefaultParams()
+
+ // Marshal the params
+ data, err := json.Marshal(&p)
+ if err != nil {
+ t.Fatalf("Marshal error: %v", err)
+ }
+
+ t.Logf("%s", string(data))
+
+ // Unmarshal the params object
+ received := Params{}
+ err = json.Unmarshal(data, &received)
+ if err != nil {
+ t.Fatalf("Unmarshal error: %v", err)
+ }
+
+ // Re-marshal this params object
+ data2, err := json.Marshal(received)
+ if err != nil {
+ t.Fatalf("Marshal error: %v", err)
+ }
+
+ t.Logf("%s", string(data2))
+
+ // Check that they match (it is done this way to avoid
+ // false failures with the reflect.DeepEqual function and
+ // pointers)
+ if !bytes.Equal(data, data2) {
+ t.Fatalf("Data was lost in marshal/unmarshal.")
+ }
+
+}
+
// Tests that DefaultParams returns a Params object with the expected defaults.
func TestDefaultParams(t *testing.T) {
expected := Params{
MaxThroughput: defaultMaxThroughput,
SendTimeout: defaultSendTimeout,
+ Cmix: cmix.GetDefaultCMIXParams(),
}
received := DefaultParams()
+ received.Cmix.Stop = expected.Cmix.Stop
if !reflect.DeepEqual(expected, received) {
t.Errorf("Received Params does not match expected."+
diff --git a/fileTransfer/send.go b/fileTransfer/send.go
index f605f7ef03aa247384830b2cb57ed81ebe4d621d..708bbf32e755779457dcc28d3fc54754f425a819 100644
--- a/fileTransfer/send.go
+++ b/fileTransfer/send.go
@@ -51,20 +51,24 @@ const (
// threads.
func (m *manager) startSendingWorkerPool(multiStop *stoppable.Multi) {
// Set up cMix sending parameters
- params := cmix.GetDefaultCMIXParams()
- params.SendTimeout = m.params.SendTimeout
- params.ExcludedRounds = sentRoundTracker.NewManager(clearSentRoundsAge)
- params.DebugTag = cMixDebugTag
+ m.params.Cmix.SendTimeout = m.params.SendTimeout
+ m.params.Cmix.ExcludedRounds =
+ sentRoundTracker.NewManager(clearSentRoundsAge)
+
+ if m.params.Cmix.DebugTag == cmix.DefaultDebugTag ||
+ m.params.Cmix.DebugTag == "" {
+ m.params.Cmix.DebugTag = cMixDebugTag
+ }
for i := 0; i < workerPoolThreads; i++ {
stop := stoppable.NewSingle(sendThreadStoppableName + strconv.Itoa(i))
multiStop.Add(stop)
- go m.sendingThread(params, stop)
+ go m.sendingThread(stop)
}
}
// sendingThread sends part packets that become available oin the send queue.
-func (m *manager) sendingThread(cMixParams cmix.CMIXParams, stop *stoppable.Single) {
+func (m *manager) sendingThread(stop *stoppable.Single) {
healthChan := make(chan bool, 10)
healthChanID := m.cmix.AddHealthCallback(func(b bool) { healthChan <- b })
for {
@@ -80,13 +84,13 @@ func (m *manager) sendingThread(cMixParams cmix.CMIXParams, stop *stoppable.Sing
healthy = <-healthChan
}
case packet := <-m.sendQueue:
- m.sendCmix(packet, cMixParams)
+ m.sendCmix(packet)
}
}
}
// sendCmix sends the parts in the packet via Cmix.SendMany.
-func (m *manager) sendCmix(packet []store.Part, cMixParams cmix.CMIXParams) {
+func (m *manager) sendCmix(packet []store.Part) {
// validParts will contain all parts in the original packet excluding those
// that return an error from GetEncryptedPart
validParts := make([]store.Part, 0, len(packet))
@@ -115,12 +119,12 @@ func (m *manager) sendCmix(packet []store.Part, cMixParams cmix.CMIXParams) {
}
// Clear all old rounds from the sent rounds list
- cMixParams.ExcludedRounds.(*sentRoundTracker.Manager).RemoveOldRounds()
+ m.params.Cmix.ExcludedRounds.(*sentRoundTracker.Manager).RemoveOldRounds()
jww.DEBUG.Printf("[FT] Sending %d file parts via SendManyCMIX",
len(messages))
- rid, _, err := m.cmix.SendMany(messages, cMixParams)
+ rid, _, err := m.cmix.SendMany(messages, m.params.Cmix)
if err != nil {
jww.WARN.Printf("[FT] Failed to send %d file parts via "+
"SendManyCMIX: %+v", len(messages), err)
diff --git a/fileTransfer/sendE2e.go b/fileTransfer/sendE2e.go
deleted file mode 100644
index 2f737bcaf9093ebad765d4ec3b4b8be5ec455689..0000000000000000000000000000000000000000
--- a/fileTransfer/sendE2e.go
+++ /dev/null
@@ -1,101 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package fileTransfer
-
-import (
- "github.com/golang/protobuf/proto"
- "github.com/pkg/errors"
- jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/client/catalog"
- "gitlab.com/elixxir/client/e2e"
- ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
- "gitlab.com/xx_network/primitives/id"
-)
-
-// Error messages.
-const (
- // manager.sendNewFileTransferMessage
- errProtoMarshal = "failed to proto marshal NewFileTransfer: %+v"
- errNewFtSendE2e = "failed to send initial file transfer message via E2E: %+v"
-
- // manager.sendEndFileTransferMessage
- errEndFtSendE2e = "[FT] Failed to send ending file transfer message via E2E: %+v"
-)
-
-const (
- // Tag that is used for log printing in SendE2E when sending the initial
- // message
- initialMessageDebugTag = "FT.New"
-
- // Tag that is used for log printing in SendE2E when sending the ending
- // message
- lastMessageDebugTag = "FT.End"
-)
-
-// sendNewFileTransferMessage sends an E2E message to the recipient informing
-// them of the incoming file transfer.
-func (m *manager) sendNewFileTransferMessage(recipient *id.ID, fileName,
- fileType string, key *ftCrypto.TransferKey, mac []byte, numParts uint16,
- fileSize uint32, retry float32, preview []byte) error {
-
- // Construct NewFileTransfer message
- protoMsg := &NewFileTransfer{
- FileName: fileName,
- FileType: fileType,
- TransferKey: key.Bytes(),
- TransferMac: mac,
- NumParts: uint32(numParts),
- Size: fileSize,
- Retry: retry,
- Preview: preview,
- }
-
- // Marshal the message
- payload, err := proto.Marshal(protoMsg)
- if err != nil {
- return errors.Errorf(errProtoMarshal, err)
- }
-
- // Get E2E parameters
- params := e2e.GetDefaultParams()
- params.ServiceTag = catalog.Silent
- params.LastServiceTag = catalog.Silent
- params.DebugTag = initialMessageDebugTag
-
- _, _, _, err = m.e2e.SendE2E(
- catalog.NewFileTransfer, recipient, payload, params)
- if err != nil {
- return errors.Errorf(errNewFtSendE2e, err)
- }
-
- return nil
-}
-
-// sendEndFileTransferMessage sends an E2E message to the recipient informing
-// them that all file parts have arrived once the network is healthy.
-func (m *manager) sendEndFileTransferMessage(recipient *id.ID) {
- callbackID := make(chan uint64, 1)
- callbackID <- m.cmix.AddHealthCallback(
- func(healthy bool) {
- if healthy {
- params := e2e.GetDefaultParams()
- params.LastServiceTag = catalog.EndFT
- params.DebugTag = lastMessageDebugTag
-
- _, _, _, err := m.e2e.SendE2E(
- catalog.EndFileTransfer, recipient, nil, params)
- if err != nil {
- jww.ERROR.Printf(errEndFtSendE2e, err)
- }
-
- cbID := <-callbackID
- m.cmix.RemoveHealthCallback(cbID)
- }
- },
- )
-}
diff --git a/fileTransfer/store/received.go b/fileTransfer/store/received.go
index 0c8c5f9c090474a57fed38dce24a6b8690a9f240..8522f6a86abad452e0c49e871e64d54ce139c8e7 100644
--- a/fileTransfer/store/received.go
+++ b/fileTransfer/store/received.go
@@ -93,8 +93,8 @@ func NewOrLoadReceived(kv *versioned.KV) (*Received, []*ReceivedTransfer, error)
// AddTransfer adds the ReceivedTransfer to the map keyed on its transfer ID.
func (r *Received) AddTransfer(key *ftCrypto.TransferKey,
- tid *ftCrypto.TransferID, fileName string, transferMAC []byte, numParts,
- numFps uint16, fileSize uint32) (*ReceivedTransfer, error) {
+ tid *ftCrypto.TransferID, fileName string, transferMAC []byte,
+ fileSize uint32, numParts, numFps uint16) (*ReceivedTransfer, error) {
r.mux.Lock()
defer r.mux.Unlock()
@@ -104,8 +104,8 @@ func (r *Received) AddTransfer(key *ftCrypto.TransferKey,
return nil, errors.Errorf(errAddExistingReceivedTransfer, tid)
}
- rt, err := newReceivedTransfer(key, tid, fileName, transferMAC, numParts,
- numFps, fileSize, r.kv)
+ rt, err := newReceivedTransfer(
+ key, tid, fileName, transferMAC, fileSize, numParts, numFps, r.kv)
if err != nil {
return nil, err
}
diff --git a/fileTransfer/store/receivedTransfer.go b/fileTransfer/store/receivedTransfer.go
index 434e32bf1d6bc66e1a6247e91f30db22bd6c2384..396925d37fad7e68a3943998a485976e96c65ea4 100644
--- a/fileTransfer/store/receivedTransfer.go
+++ b/fileTransfer/store/receivedTransfer.go
@@ -73,12 +73,12 @@ type ReceivedTransfer struct {
// The MAC for the entire file; used to verify the integrity of all parts
transferMAC []byte
- // The number of file parts in the file
- numParts uint16
-
// Size of the entire file in bytes
fileSize uint32
+ // The number of file parts in the file
+ numParts uint16
+
// Saves each part in order (has its own storage backend)
parts [][]byte
@@ -92,8 +92,8 @@ type ReceivedTransfer struct {
// newReceivedTransfer generates a ReceivedTransfer with the specified transfer
// key, transfer ID, and a number of parts.
func newReceivedTransfer(key *ftCrypto.TransferKey, tid *ftCrypto.TransferID,
- fileName string, transferMAC []byte, numParts, numFps uint16,
- fileSize uint32, kv *versioned.KV) (*ReceivedTransfer, error) {
+ fileName string, transferMAC []byte, fileSize uint32, numParts,
+ numFps uint16, kv *versioned.KV) (*ReceivedTransfer, error) {
kv = kv.Prefix(makeReceivedTransferPrefix(tid))
// Create new cypher manager
@@ -114,8 +114,8 @@ func newReceivedTransfer(key *ftCrypto.TransferKey, tid *ftCrypto.TransferID,
tid: tid,
fileName: fileName,
transferMAC: transferMAC,
- numParts: numParts,
fileSize: fileSize,
+ numParts: numParts,
parts: make([][]byte, numParts),
partStatus: partStatus,
kv: kv,
@@ -168,11 +168,6 @@ func (rt *ReceivedTransfer) GetUnusedCyphers() []cypher.Cypher {
return rt.cypherManager.GetUnusedCyphers()
}
-// NumParts returns the total number of file parts in the transfer.
-func (rt *ReceivedTransfer) NumParts() uint16 {
- return rt.numParts
-}
-
// TransferID returns the transfer's ID.
func (rt *ReceivedTransfer) TransferID() *ftCrypto.TransferID {
return rt.tid
@@ -183,6 +178,16 @@ func (rt *ReceivedTransfer) FileName() string {
return rt.fileName
}
+// FileSize returns the size of the entire file transfer.
+func (rt *ReceivedTransfer) FileSize() uint32 {
+ return rt.fileSize
+}
+
+// NumParts returns the total number of file parts in the transfer.
+func (rt *ReceivedTransfer) NumParts() uint16 {
+ return rt.numParts
+}
+
// NumReceived returns the number of parts that have been received.
func (rt *ReceivedTransfer) NumReceived() uint16 {
rt.mux.RLock()
@@ -247,8 +252,8 @@ func loadReceivedTransfer(tid *ftCrypto.TransferID, kv *versioned.KV) (
tid: tid,
fileName: fileName,
transferMAC: transferMAC,
- numParts: numParts,
fileSize: fileSize,
+ numParts: numParts,
parts: parts,
partStatus: partStatus,
kv: kv,
diff --git a/fileTransfer/store/receivedTransfer_test.go b/fileTransfer/store/receivedTransfer_test.go
index 81c3f4ced87d415c4bd61262854e9eb6bdfa453c..e1a32e74db61be43052b8dae03a358ec9c014c5c 100644
--- a/fileTransfer/store/receivedTransfer_test.go
+++ b/fileTransfer/store/receivedTransfer_test.go
@@ -27,7 +27,7 @@ func Test_newReceivedTransfer(t *testing.T) {
key, _ := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
numFps := uint16(24)
- parts := generateTestParts(16)
+ parts, _ := generateTestParts(16)
fileSize := uint32(len(parts) * len(parts[0]))
numParts := uint16(len(parts))
rtKv := kv.Prefix(makeReceivedTransferPrefix(&tid))
@@ -47,15 +47,15 @@ func Test_newReceivedTransfer(t *testing.T) {
tid: &tid,
fileName: "fileName",
transferMAC: []byte("transferMAC"),
- numParts: numParts,
fileSize: fileSize,
+ numParts: numParts,
parts: make([][]byte, numParts),
partStatus: partStatus,
kv: rtKv,
}
rt, err := newReceivedTransfer(&key, &tid, expected.fileName,
- expected.transferMAC, numParts, numFps, fileSize, kv)
+ expected.transferMAC, fileSize, numParts, numFps, kv)
if err != nil {
t.Errorf("newReceivedTransfer returned an error: %+v", err)
}
@@ -69,7 +69,7 @@ func Test_newReceivedTransfer(t *testing.T) {
// Tests that ReceivedTransfer.AddPart adds the part to the part list and marks
// it as received
func TestReceivedTransfer_AddPart(t *testing.T) {
- rt, _, _, _ := newTestReceivedTransfer(16, t)
+ rt, _, _, _, _ := newTestReceivedTransfer(16, t)
part := []byte("Part")
partNum := 6
@@ -92,7 +92,7 @@ func TestReceivedTransfer_AddPart(t *testing.T) {
// Tests that ReceivedTransfer.AddPart returns an error if the part number is
// not within the range of part numbers
func TestReceivedTransfer_AddPart_PartOutOfRangeError(t *testing.T) {
- rt, _, _, _ := newTestReceivedTransfer(16, t)
+ rt, _, _, _, _ := newTestReceivedTransfer(16, t)
expectedErr := fmt.Sprintf(errPartOutOfRange, rt.partStatus.GetNumKeys(),
rt.partStatus.GetNumKeys()-1)
@@ -108,9 +108,9 @@ func TestReceivedTransfer_AddPart_PartOutOfRangeError(t *testing.T) {
// parts are added to the transfer.
func TestReceivedTransfer_GetFile(t *testing.T) {
// Generate parts and make last file part smaller than the rest
- parts := generateTestParts(16)
+ parts, _ := generateTestParts(16)
lastPartLen := 6
- rt, _, _, _ := newTestReceivedTransfer(uint16(len(parts)), t)
+ rt, _, _, _, _ := newTestReceivedTransfer(uint16(len(parts)), t)
rt.fileSize = uint32((len(parts)-1)*len(parts[0]) + lastPartLen)
for i, p := range parts {
@@ -136,7 +136,7 @@ func TestReceivedTransfer_GetFile(t *testing.T) {
// unused cyphers.
func TestReceivedTransfer_GetUnusedCyphers(t *testing.T) {
numParts := uint16(10)
- rt, _, numFps, _ := newTestReceivedTransfer(numParts, t)
+ rt, _, _, numFps, _ := newTestReceivedTransfer(numParts, t)
// Check that all cyphers are returned after initialisation
unsentCyphers := rt.GetUnusedCyphers()
@@ -175,20 +175,9 @@ func TestReceivedTransfer_GetUnusedCyphers(t *testing.T) {
}
}
-// Tests that ReceivedTransfer.NumParts returns the correct number of parts.
-func TestReceivedTransfer_NumParts(t *testing.T) {
- numParts := uint16(16)
- rt, _, _, _ := newTestReceivedTransfer(numParts, t)
-
- if rt.NumParts() != numParts {
- t.Errorf("Incorrect number of parts.\nexpected: %d\nreceived: %d",
- numParts, rt.NumParts())
- }
-}
-
// Tests that ReceivedTransfer.TransferID returns the correct transfer ID.
func TestReceivedTransfer_TransferID(t *testing.T) {
- rt, _, _, _ := newTestReceivedTransfer(16, t)
+ rt, _, _, _, _ := newTestReceivedTransfer(16, t)
if rt.TransferID() != rt.tid {
t.Errorf("Incorrect transfer ID.\nexpected: %s\nreceived: %s",
@@ -198,7 +187,7 @@ func TestReceivedTransfer_TransferID(t *testing.T) {
// Tests that ReceivedTransfer.FileName returns the correct file name.
func TestReceivedTransfer_FileName(t *testing.T) {
- rt, _, _, _ := newTestReceivedTransfer(16, t)
+ rt, _, _, _, _ := newTestReceivedTransfer(16, t)
if rt.FileName() != rt.fileName {
t.Errorf("Incorrect transfer ID.\nexpected: %s\nreceived: %s",
@@ -206,10 +195,32 @@ func TestReceivedTransfer_FileName(t *testing.T) {
}
}
+// Tests that ReceivedTransfer.FileSize returns the correct file size.
+func TestReceivedTransfer_FileSize(t *testing.T) {
+ rt, file, _, _, _ := newTestReceivedTransfer(16, t)
+ fileSize := uint32(len(file))
+
+ if rt.FileSize() != fileSize {
+ t.Errorf("Incorrect file size.\nexpected: %d\nreceived: %d",
+ fileSize, rt.FileSize())
+ }
+}
+
+// Tests that ReceivedTransfer.NumParts returns the correct number of parts.
+func TestReceivedTransfer_NumParts(t *testing.T) {
+ numParts := uint16(16)
+ rt, _, _, _, _ := newTestReceivedTransfer(numParts, t)
+
+ if rt.NumParts() != numParts {
+ t.Errorf("Incorrect number of parts.\nexpected: %d\nreceived: %d",
+ numParts, rt.NumParts())
+ }
+}
+
// Tests that ReceivedTransfer.NumReceived returns the correct number of
// received parts.
func TestReceivedTransfer_NumReceived(t *testing.T) {
- rt, _, _, _ := newTestReceivedTransfer(16, t)
+ rt, _, _, _, _ := newTestReceivedTransfer(16, t)
if rt.NumReceived() != 0 {
t.Errorf("Incorrect number of received parts."+
@@ -231,7 +242,7 @@ func TestReceivedTransfer_NumReceived(t *testing.T) {
// Tests that the state vector returned by ReceivedTransfer.CopyPartStatusVector
// has the same values as the original but is a copy.
func TestReceivedTransfer_CopyPartStatusVector(t *testing.T) {
- rt, _, _, _ := newTestReceivedTransfer(64, t)
+ rt, _, _, _, _ := newTestReceivedTransfer(64, t)
// Check that the vectors have the same unused parts
partStatus := rt.CopyPartStatusVector()
@@ -261,8 +272,8 @@ func TestReceivedTransfer_CopyPartStatusVector(t *testing.T) {
// Tests that a ReceivedTransfer loaded via loadReceivedTransfer matches the
// original.
func Test_loadReceivedTransfer(t *testing.T) {
- parts := generateTestParts(16)
- rt, _, _, kv := newTestReceivedTransfer(uint16(len(parts)), t)
+ parts, _ := generateTestParts(16)
+ rt, _, _, _, kv := newTestReceivedTransfer(uint16(len(parts)), t)
for i, p := range parts {
if i%2 == 0 {
@@ -288,7 +299,7 @@ func Test_loadReceivedTransfer(t *testing.T) {
// Tests that ReceivedTransfer.Delete deletes the storage backend of the
// ReceivedTransfer and that it cannot be loaded again.
func TestReceivedTransfer_Delete(t *testing.T) {
- rt, _, _, kv := newTestReceivedTransfer(64, t)
+ rt, _, _, _, kv := newTestReceivedTransfer(64, t)
err := rt.Delete()
if err != nil {
@@ -304,7 +315,7 @@ func TestReceivedTransfer_Delete(t *testing.T) {
// Tests that the fields saved by ReceivedTransfer.save can be loaded from
// storage.
func TestReceivedTransfer_save(t *testing.T) {
- rt, _, _, _ := newTestReceivedTransfer(64, t)
+ rt, _, _, _, _ := newTestReceivedTransfer(64, t)
err := rt.save()
if err != nil {
@@ -319,23 +330,24 @@ func TestReceivedTransfer_save(t *testing.T) {
// newTestReceivedTransfer creates a new ReceivedTransfer for testing.
func newTestReceivedTransfer(numParts uint16, t *testing.T) (
- *ReceivedTransfer, *ftCrypto.TransferKey, uint16, *versioned.KV) {
- kv := versioned.NewKV(ekv.MakeMemstore())
- key, _ := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
+ rt *ReceivedTransfer, file []byte, key *ftCrypto.TransferKey,
+ numFps uint16, kv *versioned.KV) {
+ kv = versioned.NewKV(ekv.MakeMemstore())
+ keyTmp, _ := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
transferMAC := []byte("I am a transfer MAC")
- numFps := 2 * numParts
+ numFps = 2 * numParts
fileName := "helloFile"
- parts := generateTestParts(numParts)
- fileSize := uint32(len(parts) * len(parts[0]))
+ _, file = generateTestParts(numParts)
+ fileSize := uint32(len(file))
st, err := newReceivedTransfer(
- &key, &tid, fileName, transferMAC, numParts, numFps, fileSize, kv)
+ &keyTmp, &tid, fileName, transferMAC, fileSize, numParts, numFps, kv)
if err != nil {
t.Errorf("Failed to make new SentTransfer: %+v", err)
}
- return st, &key, numFps, kv
+ return st, file, &keyTmp, numFps, kv
}
// Tests that a ReceivedTransfer marshalled via ReceivedTransfer.marshal and
@@ -344,8 +356,8 @@ func TestReceivedTransfer_marshal_unmarshalReceivedTransfer(t *testing.T) {
rt := &ReceivedTransfer{
fileName: "transferName",
transferMAC: []byte("I am a transfer MAC"),
- numParts: 153,
fileSize: 735,
+ numParts: 153,
}
data, err := rt.marshal()
diff --git a/fileTransfer/store/received_test.go b/fileTransfer/store/received_test.go
index 83aa45f90e6fb2250ca26d1cbc5c7f28c34d73a3..4aa468f84055ed50f6b8272a858697273f20efd3 100644
--- a/fileTransfer/store/received_test.go
+++ b/fileTransfer/store/received_test.go
@@ -60,7 +60,7 @@ func TestNewOrLoadReceived_Load(t *testing.T) {
key, _ := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
rt, err2 := r.AddTransfer(&key, &tid, "file"+strconv.Itoa(i),
- []byte("transferMAC"+strconv.Itoa(i)), 10, 20, 128)
+ []byte("transferMAC"+strconv.Itoa(i)), 128, 10, 20)
if err2 != nil {
t.Errorf("Failed to add transfer #%d: %+v", i, err2)
}
@@ -108,7 +108,7 @@ func TestReceived_AddTransfer(t *testing.T) {
tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
rt, err := r.AddTransfer(
- &key, &tid, "file", []byte("transferMAC"), 10, 20, 128)
+ &key, &tid, "file", []byte("transferMAC"), 128, 10, 20)
if err != nil {
t.Errorf("Failed to add new transfer: %+v", err)
}
@@ -144,7 +144,7 @@ func TestReceived_GetTransfer(t *testing.T) {
tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
rt, err := r.AddTransfer(
- &key, &tid, "file", []byte("transferMAC"), 10, 20, 128)
+ &key, &tid, "file", []byte("transferMAC"), 128, 10, 20)
if err != nil {
t.Errorf("Failed to add new transfer: %+v", err)
}
@@ -170,7 +170,7 @@ func TestReceived_RemoveTransfer(t *testing.T) {
tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
rt, err := r.AddTransfer(
- &key, &tid, "file", []byte("transferMAC"), 10, 20, 128)
+ &key, &tid, "file", []byte("transferMAC"), 128, 10, 20)
if err != nil {
t.Errorf("Failed to add new transfer: %+v", err)
}
diff --git a/fileTransfer/store/sent.go b/fileTransfer/store/sent.go
index 9ca7f482e53540adff504c932ad39219225e39fa..7873d5b469bafc8666b0951d55d7852aff0c1ae6 100644
--- a/fileTransfer/store/sent.go
+++ b/fileTransfer/store/sent.go
@@ -102,8 +102,8 @@ func NewOrLoadSent(kv *versioned.KV) (*Sent, []Part, error) {
// AddTransfer creates a SentTransfer and adds it to the map keyed on its
// transfer ID.
func (s *Sent) AddTransfer(recipient *id.ID, key *ftCrypto.TransferKey,
- tid *ftCrypto.TransferID, fileName string, parts [][]byte, numFps uint16) (
- *SentTransfer, error) {
+ tid *ftCrypto.TransferID, fileName string, fileSize uint32, parts [][]byte,
+ numFps uint16) (*SentTransfer, error) {
s.mux.Lock()
defer s.mux.Unlock()
@@ -112,7 +112,8 @@ func (s *Sent) AddTransfer(recipient *id.ID, key *ftCrypto.TransferKey,
return nil, errors.Errorf(errAddExistingSentTransfer, tid)
}
- st, err := newSentTransfer(recipient, key, tid, fileName, parts, numFps, s.kv)
+ st, err := newSentTransfer(
+ recipient, key, tid, fileName, fileSize, parts, numFps, s.kv)
if err != nil {
return nil, errors.Errorf(errNewSentTransfer, tid)
}
diff --git a/fileTransfer/store/sentTransfer.go b/fileTransfer/store/sentTransfer.go
index dbd4033a85a0b6315e9d052d230557a822612a33..05046f183ac073c35d45fd088ea4a3df15d7c88c 100644
--- a/fileTransfer/store/sentTransfer.go
+++ b/fileTransfer/store/sentTransfer.go
@@ -68,6 +68,9 @@ type SentTransfer struct {
// ID of the recipient of the file transfer
recipient *id.ID
+ // The size of the entire file
+ fileSize uint32
+
// The number of file parts in the file
numParts uint16
@@ -87,8 +90,8 @@ type SentTransfer struct {
// newSentTransfer generates a new SentTransfer with the specified transfer key,
// transfer ID, and parts.
func newSentTransfer(recipient *id.ID, key *ftCrypto.TransferKey,
- tid *ftCrypto.TransferID, fileName string, parts [][]byte, numFps uint16,
- kv *versioned.KV) (*SentTransfer, error) {
+ tid *ftCrypto.TransferID, fileName string, fileSize uint32, parts [][]byte,
+ numFps uint16, kv *versioned.KV) (*SentTransfer, error) {
kv = kv.Prefix(makeSentTransferPrefix(tid))
// Create new cypher manager
@@ -109,6 +112,7 @@ func newSentTransfer(recipient *id.ID, key *ftCrypto.TransferKey,
tid: tid,
fileName: fileName,
recipient: recipient,
+ fileSize: fileSize,
numParts: uint16(len(parts)),
status: Running,
parts: parts,
@@ -173,11 +177,6 @@ func (st *SentTransfer) Status() TransferStatus {
return st.status
}
-// NumParts returns the total number of file parts in the transfer.
-func (st *SentTransfer) NumParts() uint16 {
- return st.numParts
-}
-
// TransferID returns the transfer's ID.
func (st *SentTransfer) TransferID() *ftCrypto.TransferID {
return st.tid
@@ -193,6 +192,16 @@ func (st *SentTransfer) Recipient() *id.ID {
return st.recipient
}
+// FileSize returns the size of the entire file transfer.
+func (st *SentTransfer) FileSize() uint32 {
+ return st.fileSize
+}
+
+// NumParts returns the total number of file parts in the transfer.
+func (st *SentTransfer) NumParts() uint16 {
+ return st.numParts
+}
+
// NumArrived returns the number of parts that have arrived.
func (st *SentTransfer) NumArrived() uint16 {
return uint16(st.partStatus.GetNumUsed())
@@ -243,6 +252,7 @@ func loadSentTransfer(tid *ftCrypto.TransferID, kv *versioned.KV) (
tid: tid,
fileName: fileName,
recipient: recipient,
+ fileSize: calcFileSize(parts),
numParts: uint16(len(parts)),
status: status,
parts: parts,
@@ -253,6 +263,14 @@ func loadSentTransfer(tid *ftCrypto.TransferID, kv *versioned.KV) (
return st, nil
}
+// calcFileSize calculates the size of the entire file from a list of parts. All
+// parts, except the last, are assumed to have the same length.
+func calcFileSize(parts [][]byte) uint32 {
+ lastPartSize := len(parts[len(parts)-1])
+ otherPartsSize := len(parts[0]) * (len(parts) - 1)
+ return uint32(lastPartSize + otherPartsSize)
+}
+
// Delete deletes all data in the SentTransfer from storage.
func (st *SentTransfer) Delete() error {
st.mux.Lock()
diff --git a/fileTransfer/store/sentTransfer_test.go b/fileTransfer/store/sentTransfer_test.go
index 7d44dd65b883844f4778693362108bc58994e76c..a9366ce8057dbaac8641bcd9132d54e2dfcb41f4 100644
--- a/fileTransfer/store/sentTransfer_test.go
+++ b/fileTransfer/store/sentTransfer_test.go
@@ -49,6 +49,7 @@ func Test_newSentTransfer(t *testing.T) {
tid: &tid,
fileName: "file",
recipient: id.NewIdFromString("user", id.User, t),
+ fileSize: calcFileSize(parts),
numParts: uint16(len(parts)),
status: Running,
parts: parts,
@@ -56,8 +57,8 @@ func Test_newSentTransfer(t *testing.T) {
kv: stKv,
}
- st, err := newSentTransfer(
- expected.recipient, &key, &tid, expected.fileName, parts, numFps, kv)
+ st, err := newSentTransfer(expected.recipient, &key, &tid,
+ expected.fileName, expected.fileSize, parts, numFps, kv)
if err != nil {
t.Errorf("newSentTransfer returned an error: %+v", err)
}
@@ -228,17 +229,6 @@ func TestSentTransfer_Status(t *testing.T) {
}
}
-// Tests that SentTransfer.NumParts returns the correct number of parts.
-func TestSentTransfer_NumParts(t *testing.T) {
- numParts := uint16(16)
- st, _, _, _, _ := newTestSentTransfer(numParts, t)
-
- if st.NumParts() != numParts {
- t.Errorf("Incorrect number of parts.\nexpected: %d\nreceived: %d",
- numParts, st.NumParts())
- }
-}
-
// Tests that SentTransfer.TransferID returns the correct transfer ID.
func TestSentTransfer_TransferID(t *testing.T) {
st, _, _, _, _ := newTestSentTransfer(16, t)
@@ -269,6 +259,28 @@ func TestSentTransfer_Recipient(t *testing.T) {
}
}
+// Tests that SentTransfer.FileSize returns the correct file size.
+func TestSentTransfer_FileSize(t *testing.T) {
+ st, parts, _, _, _ := newTestSentTransfer(16, t)
+ fileSize := calcFileSize(parts)
+
+ if st.FileSize() != fileSize {
+ t.Errorf("Incorrect file size.\nexpected: %d\nreceived: %d",
+ fileSize, st.FileSize())
+ }
+}
+
+// Tests that SentTransfer.NumParts returns the correct number of parts.
+func TestSentTransfer_NumParts(t *testing.T) {
+ numParts := uint16(16)
+ st, _, _, _, _ := newTestSentTransfer(numParts, t)
+
+ if st.NumParts() != numParts {
+ t.Errorf("Incorrect number of parts.\nexpected: %d\nreceived: %d",
+ numParts, st.NumParts())
+ }
+}
+
// Tests that SentTransfer.NumArrived returns the correct number of arrived
// parts.
func TestSentTransfer_NumArrived(t *testing.T) {
@@ -437,37 +449,41 @@ func Test_makeSentTransferPrefix_Consistency(t *testing.T) {
const numPrimeBytes = 512
// newTestSentTransfer creates a new SentTransfer for testing.
-func newTestSentTransfer(numParts uint16, t *testing.T) (
- *SentTransfer, [][]byte, *ftCrypto.TransferKey, uint16, *versioned.KV) {
- kv := versioned.NewKV(ekv.MakeMemstore())
+func newTestSentTransfer(numParts uint16, t *testing.T) (st *SentTransfer,
+ parts [][]byte, key *ftCrypto.TransferKey, numFps uint16, kv *versioned.KV) {
+ kv = versioned.NewKV(ekv.MakeMemstore())
recipient := id.NewIdFromString("recipient", id.User, t)
- key, _ := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
+ keyTmp, _ := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
- numFps := 2 * numParts
+ numFps = 2 * numParts
fileName := "helloFile"
- parts := generateTestParts(numParts)
+ parts, file := generateTestParts(numParts)
- st, err := newSentTransfer(recipient, &key, &tid, fileName, parts, numFps, kv)
+ st, err := newSentTransfer(
+ recipient, &keyTmp, &tid, fileName, uint32(len(file)), parts, numFps, kv)
if err != nil {
t.Errorf("Failed to make new SentTransfer: %+v", err)
}
- return st, parts, &key, numFps, kv
+ return st, parts, &keyTmp, numFps, kv
}
// generateTestParts generates a list of file parts of the correct size to be
// encrypted/decrypted.
-func generateTestParts(numParts uint16) [][]byte {
+func generateTestParts(numParts uint16) (parts [][]byte, file []byte) {
// Calculate part size
partSize := fileMessage.NewPartMessage(
format.NewMessage(numPrimeBytes).ContentsSize()).GetPartSize()
// Create list of parts and fill
- parts := make([][]byte, numParts)
+ parts = make([][]byte, numParts)
+ var buff bytes.Buffer
+ buff.Grow(int(numParts) * partSize)
for i := range parts {
parts[i] = make([]byte, partSize)
copy(parts[i], "Hello "+strconv.Itoa(i))
+ buff.Write(parts[i])
}
- return parts
+ return parts, buff.Bytes()
}
diff --git a/fileTransfer/store/sent_test.go b/fileTransfer/store/sent_test.go
index b6debe981429ccc40ff1898dfdb4cef47c185441..f07a5996c2ba9844faeeffecaed6c171eecb4851 100644
--- a/fileTransfer/store/sent_test.go
+++ b/fileTransfer/store/sent_test.go
@@ -60,10 +60,11 @@ func TestNewOrLoadSent_Load(t *testing.T) {
for i := 0; i < 10; i++ {
key, _ := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
+ parts, file := generateTestParts(uint16(10 + i))
st, err2 := s.AddTransfer(
id.NewIdFromString("recipient"+strconv.Itoa(i), id.User, t),
- &key, &tid, "file"+strconv.Itoa(i),
- generateTestParts(uint16(10+i)), uint16(2*(10+i)))
+ &key, &tid, "file"+strconv.Itoa(i), uint32(len(file)), parts,
+ uint16(2*(10+i)))
if err2 != nil {
t.Errorf("Failed to add transfer #%d: %+v", i, err2)
}
@@ -123,9 +124,10 @@ func TestSent_AddTransfer(t *testing.T) {
key, _ := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
+ parts, file := generateTestParts(10)
st, err := s.AddTransfer(id.NewIdFromString("recipient", id.User, t),
- &key, &tid, "file", generateTestParts(10), 20)
+ &key, &tid, "file", uint32(len(file)), parts, 20)
if err != nil {
t.Errorf("Failed to add new transfer: %+v", err)
}
@@ -145,7 +147,7 @@ func TestSent_AddTransfer_TransferAlreadyExists(t *testing.T) {
}
expectedErr := fmt.Sprintf(errAddExistingSentTransfer, tid)
- _, err := s.AddTransfer(nil, nil, &tid, "", nil, 0)
+ _, err := s.AddTransfer(nil, nil, &tid, "", 0, nil, 0)
if err == nil || err.Error() != expectedErr {
t.Errorf("Received unexpected error when adding transfer that already "+
"exists.\nexpected: %s\nreceived: %+v", expectedErr, err)
@@ -159,9 +161,10 @@ func TestSent_GetTransfer(t *testing.T) {
key, _ := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
+ parts, file := generateTestParts(10)
st, err := s.AddTransfer(id.NewIdFromString("recipient", id.User, t),
- &key, &tid, "file", generateTestParts(10), 20)
+ &key, &tid, "file", uint32(len(file)), parts, 20)
if err != nil {
t.Errorf("Failed to add new transfer: %+v", err)
}
@@ -185,9 +188,10 @@ func TestSent_RemoveTransfer(t *testing.T) {
key, _ := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
+ parts, file := generateTestParts(10)
st, err := s.AddTransfer(id.NewIdFromString("recipient", id.User, t),
- &key, &tid, "file", generateTestParts(10), 20)
+ &key, &tid, "file", uint32(len(file)), parts, 20)
if err != nil {
t.Errorf("Failed to add new transfer: %+v", err)
}
diff --git a/fileTransfer/utils_test.go b/fileTransfer/utils_test.go
index 0fe87093612f4229ebe8f276c82be74f7a212caf..781734369b36270a4c2e9298b2eaa747e1c10655 100644
--- a/fileTransfer/utils_test.go
+++ b/fileTransfer/utils_test.go
@@ -11,18 +11,19 @@ import (
"bytes"
"encoding/binary"
jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/client/catalog"
"gitlab.com/elixxir/client/cmix"
"gitlab.com/elixxir/client/cmix/identity/receptionID"
"gitlab.com/elixxir/client/cmix/message"
"gitlab.com/elixxir/client/cmix/rounds"
- "gitlab.com/elixxir/client/e2e"
- "gitlab.com/elixxir/client/e2e/receive"
- e2eCrypto "gitlab.com/elixxir/crypto/e2e"
+ "gitlab.com/elixxir/client/storage/versioned"
+ "gitlab.com/elixxir/crypto/cyclic"
+ "gitlab.com/elixxir/crypto/fastRNG"
+ "gitlab.com/elixxir/ekv"
"gitlab.com/elixxir/primitives/format"
+ "gitlab.com/xx_network/crypto/csprng"
+ "gitlab.com/xx_network/crypto/large"
"gitlab.com/xx_network/primitives/id"
"gitlab.com/xx_network/primitives/id/ephemeral"
- "gitlab.com/xx_network/primitives/netTime"
"io"
"math/rand"
"sync"
@@ -101,16 +102,19 @@ type mockCmix struct {
handler *mockCmixHandler
healthCBs map[uint64]func(b bool)
healthIndex uint64
+ round id.Round
sync.Mutex
}
-func newMockCmix(myID *id.ID, handler *mockCmixHandler) *mockCmix {
+func newMockCmix(
+ myID *id.ID, handler *mockCmixHandler, storage *mockStorage) *mockCmix {
return &mockCmix{
myID: myID,
- numPrimeBytes: 4096,
+ numPrimeBytes: storage.GetCmixGroup().GetP().ByteLen(),
health: true,
handler: handler,
healthCBs: make(map[uint64]func(b bool)),
+ round: 0,
healthIndex: 0,
}
}
@@ -123,6 +127,9 @@ func (m *mockCmix) GetMaxMessageLength() int {
func (m *mockCmix) SendMany(messages []cmix.TargetedCmixMessage,
_ cmix.CMIXParams) (id.Round, []ephemeral.Id, error) {
m.handler.Lock()
+ defer m.handler.Unlock()
+ round := m.round
+ m.round++
for _, targetedMsg := range messages {
msg := format.NewMessage(m.numPrimeBytes)
msg.SetContents(targetedMsg.Payload)
@@ -130,25 +137,26 @@ func (m *mockCmix) SendMany(messages []cmix.TargetedCmixMessage,
msg.SetKeyFP(targetedMsg.Fingerprint)
m.handler.processorMap[targetedMsg.Fingerprint].Process(msg,
receptionID.EphemeralIdentity{Source: targetedMsg.Recipient},
- rounds.Round{ID: 42})
+ rounds.Round{ID: round})
}
- m.handler.Unlock()
- return 42, []ephemeral.Id{}, nil
+ return round, []ephemeral.Id{}, nil
}
func (m *mockCmix) AddFingerprint(_ *id.ID, fp format.Fingerprint, mp message.Processor) error {
- m.Lock()
- defer m.Unlock()
+ m.handler.Lock()
+ defer m.handler.Unlock()
m.handler.processorMap[fp] = mp
return nil
}
func (m *mockCmix) DeleteFingerprint(_ *id.ID, fp format.Fingerprint) {
m.handler.Lock()
+ defer m.handler.Unlock()
delete(m.handler.processorMap, fp)
- m.handler.Unlock()
}
+func (m *mockCmix) CheckInProgressMessages() {}
+
func (m *mockCmix) IsHealthy() bool {
return m.health
}
@@ -174,74 +182,31 @@ func (m *mockCmix) RemoveHealthCallback(healthID uint64) {
}
func (m *mockCmix) GetRoundResults(_ time.Duration,
- roundCallback cmix.RoundEventCallback, _ ...id.Round) error {
- go roundCallback(true, false, map[id.Round]cmix.RoundResult{42: {}})
+ roundCallback cmix.RoundEventCallback, rids ...id.Round) error {
+ go roundCallback(true, false, map[id.Round]cmix.RoundResult{rids[0]: {}})
return nil
}
////////////////////////////////////////////////////////////////////////////////
-// Mock E2E Handler //
+// Mock Storage Session //
////////////////////////////////////////////////////////////////////////////////
-func newMockListener(hearChan chan receive.Message) *mockListener {
- return &mockListener{hearChan: hearChan}
-}
-func (l *mockListener) Hear(item receive.Message) {
- l.hearChan <- item
+type mockStorage struct {
+ kv *versioned.KV
+ cmixGroup *cyclic.Group
}
-func (l *mockListener) Name() string {
- return "mockListener"
-}
+func newMockStorage() *mockStorage {
+ b := make([]byte, 768)
+ rng := fastRNG.NewStreamGenerator(1000, 10, csprng.NewSystemRNG).GetStream()
+ _, _ = rng.Read(b)
+ rng.Close()
-type mockE2eHandler struct {
- msgMap map[id.ID]map[catalog.MessageType][][]byte
- listeners map[id.ID]map[catalog.MessageType]receive.Listener
-}
-
-func newMockE2eHandler() *mockE2eHandler {
- return &mockE2eHandler{
- msgMap: make(map[id.ID]map[catalog.MessageType][][]byte),
- listeners: make(map[id.ID]map[catalog.MessageType]receive.Listener),
+ return &mockStorage{
+ kv: versioned.NewKV(ekv.MakeMemstore()),
+ cmixGroup: cyclic.NewGroup(large.NewIntFromBytes(b), large.NewInt(2)),
}
}
-type mockE2e struct {
- myID *id.ID
- handler *mockE2eHandler
-}
-
-type mockListener struct {
- hearChan chan receive.Message
-}
-
-func newMockE2e(myID *id.ID, handler *mockE2eHandler) *mockE2e {
- return &mockE2e{
- myID: myID,
- handler: handler,
- }
-}
-
-// SendE2E adds the message to the e2e handler map.
-func (m *mockE2e) SendE2E(mt catalog.MessageType, recipient *id.ID, payload []byte,
- _ e2e.Params) ([]id.Round, e2eCrypto.MessageID, time.Time, error) {
-
- m.handler.listeners[*recipient][mt].Hear(receive.Message{
- MessageType: mt,
- Payload: payload,
- Sender: m.myID,
- RecipientID: recipient,
- })
-
- return []id.Round{42}, e2eCrypto.MessageID{}, netTime.Now(), nil
-}
-
-func (m *mockE2e) RegisterListener(senderID *id.ID, mt catalog.MessageType,
- listener receive.Listener) receive.ListenerID {
- if _, exists := m.handler.listeners[*senderID]; !exists {
- m.handler.listeners[*senderID] = map[catalog.MessageType]receive.Listener{mt: listener}
- } else if _, exists = m.handler.listeners[*senderID][mt]; !exists {
- m.handler.listeners[*senderID][mt] = listener
- }
- return receive.ListenerID{}
-}
+func (m *mockStorage) GetKV() *versioned.KV { return m.kv }
+func (m *mockStorage) GetCmixGroup() *cyclic.Group { return m.cmixGroup }
diff --git a/fileTransfer2/batchBuilder.go b/fileTransfer2/batchBuilder.go
deleted file mode 100644
index 907bed21f60747e4e2583c8bb5cdfb7ec3d1e803..0000000000000000000000000000000000000000
--- a/fileTransfer2/batchBuilder.go
+++ /dev/null
@@ -1,127 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package fileTransfer2
-
-import (
- "encoding/binary"
- jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/client/fileTransfer2/store"
- "gitlab.com/elixxir/client/stoppable"
- "gitlab.com/elixxir/crypto/cyclic"
- "gitlab.com/elixxir/crypto/fastRNG"
- "gitlab.com/elixxir/primitives/format"
- "gitlab.com/xx_network/crypto/csprng"
- "go.uber.org/ratelimit"
- "time"
-)
-
-const (
- // Duration to wait before adding a partially filled part packet to the send
- // channel.
- unfilledPacketTimeout = 100 * time.Millisecond
-)
-
-// batchBuilderThread creates batches of file parts as they become available and
-// buffer them to send. Also rate limits adding to the buffer.
-func (m *manager) batchBuilderThread(stop *stoppable.Single) {
- // Calculate rate and make rate limiter
- rl := newRateLimiter(m.params.MaxThroughput, m.cmixGroup)
-
- // Build each batch and add to the queue
- for {
- numParts := generateRandomPacketSize(m.rng)
- packet := make([]store.Part, 0, numParts)
- delayedTimer := NewDelayedTimer(unfilledPacketTimeout)
- loop:
- for cap(packet) > len(packet) {
- select {
- case <-stop.Quit():
- delayedTimer.Stop()
- jww.DEBUG.Printf("[FT] Stopping file part packing thread " +
- "while packing: stoppable triggered.")
- stop.ToStopped()
- return
- case <-*delayedTimer.C:
- break loop
- case p := <-m.batchQueue:
- packet = append(packet, p)
- delayedTimer.Start()
- }
- }
-
- // Rate limiter
- rl.Take()
- m.sendQueue <- packet
- }
-}
-
-// newRateLimiter generates a new ratelimit.Limiter that limits the bandwidth to
-// the given max throughput (in bytes per second).
-func newRateLimiter(
- maxThroughput int, cmixGroup *cyclic.Group) ratelimit.Limiter {
- // Calculate rate and make rate limiter if max throughput is set
- if maxThroughput > 0 {
- // Calculate the average amount of data sent in each batch
- messageSize := format.NewMessage(cmixGroup.GetP().ByteLen()).ContentsSize()
- avgNumMessages := (minPartsSendPerRound + maxPartsSendPerRound) / 2
- avgSendSize := avgNumMessages * messageSize
-
- jww.DEBUG.Printf("[FT] Rate limiting parameters: message size: %d, "+
- "average number of messages per send: %d, average size of send: %d",
- messageSize, avgNumMessages, avgSendSize)
-
- // Calculate the time window needed to achieve the desired bandwidth
- per := time.Second
- switch {
- case avgSendSize < maxThroughput:
- per = time.Second
- case avgSendSize < maxThroughput*60:
- per = time.Minute
- case avgSendSize < maxThroughput*60*60:
- per = time.Hour
- case avgSendSize < maxThroughput*60*60*24:
- per = time.Hour * 24
- case avgSendSize < maxThroughput*60*60*24*7:
- per = time.Hour * 24 * 7
- }
-
- // Calculate the rate of messages per time window
- rate := int((float64(maxThroughput) / float64(avgSendSize)) *
- float64(per/time.Second))
-
- jww.INFO.Printf("[FT] Max throughput is %d bytes/second. "+
- "File transfer will be rate limited to %d per %s.",
- maxThroughput, rate, per)
-
- return ratelimit.New(rate, ratelimit.WithoutSlack, ratelimit.Per(per))
- }
-
- // If the max throughput is zero, then create an unlimited rate limiter
- jww.WARN.Printf("[FT] Max throughput is %d bytes/second. "+
- "File transfer will not be rate limited.", maxThroughput)
- return ratelimit.NewUnlimited()
-}
-
-// generateRandomPacketSize returns a random number between minPartsSendPerRound
-// and maxPartsSendPerRound, inclusive.
-func generateRandomPacketSize(rngGen *fastRNG.StreamGenerator) int {
- rng := rngGen.GetStream()
- defer rng.Close()
-
- // Generate random bytes
- b, err := csprng.Generate(8, rng)
- if err != nil {
- jww.FATAL.Panicf(getRandomNumPartsRandPanic, err)
- }
-
- // Convert bytes to integer
- num := binary.LittleEndian.Uint64(b)
-
- // Return random number that is minPartsSendPerRound <= num <= max
- return int((num % (maxPartsSendPerRound)) + minPartsSendPerRound)
-}
diff --git a/fileTransfer2/callbackTracker/callbackTracker.go b/fileTransfer2/callbackTracker/callbackTracker.go
deleted file mode 100644
index 6cf7a641c10b2fccf96b46097a5c18dbabea3655..0000000000000000000000000000000000000000
--- a/fileTransfer2/callbackTracker/callbackTracker.go
+++ /dev/null
@@ -1,99 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package callbackTracker
-
-import (
- "gitlab.com/elixxir/client/stoppable"
- "gitlab.com/xx_network/primitives/netTime"
- "sync"
- "time"
-)
-
-type callback func(err error)
-
-// callbackTracker tracks the fileTransfer.SentProgressCallback and
-// information on when to call it. The callback will be called on each send,
-// unless the time since the lastCall is smaller than the period. In that case,
-// a callback is marked as scheduled and waits to be called at the end of the
-// period. A callback is called once every period, regardless of the number of
-// sends that occur.
-type callbackTracker struct {
- period time.Duration // How often to call the callback
- lastCall time.Time // Timestamp of the last call
- scheduled bool // Denotes if callback call is scheduled
- complete bool // Denotes if the callback should not be called
- stop *stoppable.Single // Stops the scheduled callback from triggering
- cb callback
- mux sync.RWMutex
-}
-
-// newCallbackTracker creates a new and unused sentCallbackTracker.
-func newCallbackTracker(
- cb callback, period time.Duration, stop *stoppable.Single) *callbackTracker {
- return &callbackTracker{
- period: period,
- lastCall: time.Time{},
- scheduled: false,
- complete: false,
- stop: stop,
- cb: cb,
- }
-}
-
-// call triggers the progress callback with the most recent progress from the
-// sentProgressTracker. If a callback has been called within the last period,
-// then a new call is scheduled to occur at the beginning of the next period. If
-// a call is already scheduled, then nothing happens; when the callback is
-// finally called, it will do so with the most recent changes.
-func (ct *callbackTracker) call(err error) {
- ct.mux.RLock()
- // Exit if a callback is already scheduled
- if (ct.scheduled || ct.complete) && err == nil {
- ct.mux.RUnlock()
- return
- }
-
- ct.mux.RUnlock()
- ct.mux.Lock()
- defer ct.mux.Unlock()
-
- if (ct.scheduled || ct.complete) && err == nil {
- return
- }
-
- // Mark callback complete if an error is passed
- ct.complete = err != nil
-
- // Check if a callback has occurred within the last period
- timeSinceLastCall := netTime.Since(ct.lastCall)
- if timeSinceLastCall > ct.period {
-
- // If no callback occurred, then trigger the callback now
- go ct.cb(err)
- ct.lastCall = netTime.Now()
- } else {
- // If a callback did occur, then schedule a new callback to occur at the
- // start of the next period
- ct.scheduled = true
- go func() {
- timer := time.NewTimer(ct.period - timeSinceLastCall)
- select {
- case <-ct.stop.Quit():
- timer.Stop()
- ct.stop.ToStopped()
- return
- case <-timer.C:
- ct.mux.Lock()
- go ct.cb(err)
- ct.lastCall = netTime.Now()
- ct.scheduled = false
- ct.mux.Unlock()
- }
- }()
- }
-}
diff --git a/fileTransfer2/callbackTracker/callbackTracker_test.go b/fileTransfer2/callbackTracker/callbackTracker_test.go
deleted file mode 100644
index 7ffbe6636f3bc8abd56db36befbc699bfba22181..0000000000000000000000000000000000000000
--- a/fileTransfer2/callbackTracker/callbackTracker_test.go
+++ /dev/null
@@ -1,148 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package callbackTracker
-
-import (
- "github.com/pkg/errors"
- "gitlab.com/elixxir/client/stoppable"
- "reflect"
- "testing"
- "time"
-)
-
-// Tests that newCallbackTracker returns a new callbackTracker with all the
-// expected values.
-func Test_newCallbackTracker(t *testing.T) {
- expected := &callbackTracker{
- period: time.Millisecond,
- lastCall: time.Time{},
- scheduled: false,
- complete: false,
- stop: stoppable.NewSingle("Test_newCallbackTracker"),
- }
-
- newCT := newCallbackTracker(nil, expected.period, expected.stop)
- newCT.cb = nil
-
- if !reflect.DeepEqual(expected, newCT) {
- t.Errorf("New callbackTracker does not match expected."+
- "\nexpected: %+v\nreceived: %+v", expected, newCT)
- }
-}
-
-// Tests four test cases of callbackTracker.call:
-// 1. An initial call is not scheduled.
-// 2. A second call within the periods is only called after the period.
-// 3. An error sets the callback to complete.
-// 4. No more callbacks will be called after set to complete.
-func Test_callbackTracker_call(t *testing.T) {
- cbChan := make(chan error, 10)
- cb := func(err error) { cbChan <- err }
- stop := stoppable.NewSingle("Test_callbackTracker_call")
- ct := newCallbackTracker(cb, 250*time.Millisecond, stop)
-
- // Test that the initial call is unscheduled and is called before the period
- go ct.call(nil)
-
- select {
- case r := <-cbChan:
- if r != nil {
- t.Errorf("Received error: %+v", r)
- }
- case <-time.After(35 * time.Millisecond):
- t.Error("Timed out waiting for callback.")
- }
-
- // Test that another call within the period is called only after the period
- // is reached
- go ct.call(nil)
-
- select {
- case <-cbChan:
- t.Error("Callback called too soon.")
-
- case <-time.After(35 * time.Millisecond):
- ct.mux.RLock()
- if !ct.scheduled {
- t.Error("Callback is not scheduled when it should be.")
- }
- ct.mux.RUnlock()
- select {
- case r := <-cbChan:
- if r != nil {
- t.Errorf("Received error: %+v", r)
- }
- case <-time.After(ct.period):
- t.Errorf("Callback not called after period %s.", ct.period)
-
- if ct.scheduled {
- t.Error("Callback is scheduled when it should not be.")
- }
- }
- }
-
- // Test that calling with an error sets the callback to complete
- expectedErr := errors.New("test error")
- go ct.call(expectedErr)
-
- select {
- case r := <-cbChan:
- if r != expectedErr {
- t.Errorf("Received incorrect error.\nexpected: %v\nreceived: %v",
- expectedErr, r)
- }
- if !ct.complete {
- t.Error("Callback is not marked complete when it should be.")
- }
- case <-time.After(ct.period + 25*time.Millisecond):
- t.Errorf("Callback not called after period %s.",
- ct.period+15*time.Millisecond)
- }
-
- // Tests that all callback calls after an error are blocked
- go ct.call(nil)
-
- select {
- case r := <-cbChan:
- t.Errorf("Received callback when it should have been completed: %+v", r)
- case <-time.After(ct.period):
- }
-}
-
-// Tests that callbackTracker.call does not call on the callback when the
-// stoppable is triggered.
-func Test_callbackTracker_call_stop(t *testing.T) {
- cbChan := make(chan error, 10)
- cb := func(err error) { cbChan <- err }
- stop := stoppable.NewSingle("Test_callbackTracker_call")
- ct := newCallbackTracker(cb, 250*time.Millisecond, stop)
-
- go ct.call(nil)
-
- select {
- case r := <-cbChan:
- if r != nil {
- t.Errorf("Received error: %+v", r)
- }
- case <-time.After(25 * time.Millisecond):
- t.Error("Timed out waiting for callback.")
- }
-
- go ct.call(nil)
-
- err := stop.Close()
- if err != nil {
- t.Errorf("Failed closing stoppable: %+v", err)
- }
-
- select {
- case <-cbChan:
- t.Error("Callback called.")
- case <-time.After(ct.period * 2):
- }
-}
diff --git a/fileTransfer2/callbackTracker/manager.go b/fileTransfer2/callbackTracker/manager.go
deleted file mode 100644
index e6c4cf437ad0d625454667950d2a136baa8f20d2..0000000000000000000000000000000000000000
--- a/fileTransfer2/callbackTracker/manager.go
+++ /dev/null
@@ -1,99 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package callbackTracker
-
-import (
- jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/client/stoppable"
- ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
- "strconv"
- "sync"
- "time"
-)
-
-// Manager tracks the callbacks for each transfer.
-type Manager struct {
- // Map of transfers and their list of callbacks
- callbacks map[ftCrypto.TransferID][]*callbackTracker
-
- // List of multi stoppables used to stop callback trackers; each multi
- // stoppable contains a single stoppable for each callback.
- stops map[ftCrypto.TransferID]*stoppable.Multi
-
- mux sync.RWMutex
-}
-
-// NewManager initializes a new callback tracker Manager.
-func NewManager() *Manager {
- m := &Manager{
- callbacks: make(map[ftCrypto.TransferID][]*callbackTracker),
- stops: make(map[ftCrypto.TransferID]*stoppable.Multi),
- }
-
- return m
-}
-
-// AddCallback adds a callback to the list of callbacks for the given transfer
-// ID and calls it regardless of the callback tracker status.
-func (m *Manager) AddCallback(
- tid *ftCrypto.TransferID, cb callback, period time.Duration) {
- m.mux.Lock()
- defer m.mux.Unlock()
-
- // Create new entries for this transfer ID if none exist
- if _, exists := m.callbacks[*tid]; !exists {
- m.callbacks[*tid] = []*callbackTracker{}
- m.stops[*tid] = stoppable.NewMulti("FileTransfer/" + tid.String())
- }
-
- // Generate the stoppable and add it to the transfer's multi stoppable
- stop := stoppable.NewSingle(makeStoppableName(tid, len(m.callbacks[*tid])))
- m.stops[*tid].Add(stop)
-
- // Create new callback tracker and add to the map
- ct := newCallbackTracker(cb, period, stop)
- m.callbacks[*tid] = append(m.callbacks[*tid], ct)
-
- // Call the callback
- go cb(nil)
-}
-
-// Call triggers each callback for the given transfer ID and passes along the
-// given error.
-func (m *Manager) Call(tid *ftCrypto.TransferID, err error) {
- m.mux.Lock()
- defer m.mux.Unlock()
-
- for _, cb := range m.callbacks[*tid] {
- go cb.call(err)
- }
-}
-
-// Delete stops all scheduled stoppables for the given transfer and deletes the
-// callbacks from the map.
-func (m *Manager) Delete(tid *ftCrypto.TransferID) {
- m.mux.Lock()
- defer m.mux.Unlock()
-
- // Stop the stoppable if the stoppable still exists
- stop, exists := m.stops[*tid]
- if exists {
- if err := stop.Close(); err != nil {
- jww.ERROR.Printf("[FT] Failed to stop progress callbacks: %+v", err)
- }
- }
-
- // Delete callbacks and stoppables
- delete(m.callbacks, *tid)
- delete(m.stops, *tid)
-}
-
-// makeStoppableName generates a unique name for the callback stoppable.
-func makeStoppableName(tid *ftCrypto.TransferID, callbackNum int) string {
- return tid.String() + "/" + strconv.Itoa(callbackNum)
-}
diff --git a/fileTransfer2/callbackTracker/manager_test.go b/fileTransfer2/callbackTracker/manager_test.go
deleted file mode 100644
index 4226807f18a728345fc4907758bd27ae21b6dcc1..0000000000000000000000000000000000000000
--- a/fileTransfer2/callbackTracker/manager_test.go
+++ /dev/null
@@ -1,176 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package callbackTracker
-
-import (
- "errors"
- "gitlab.com/elixxir/client/stoppable"
- ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
- "gitlab.com/xx_network/crypto/csprng"
- "io"
- "math/rand"
- "reflect"
- "sync"
- "testing"
- "time"
-)
-
-// Tests that NewManager returns the expected Manager.
-func TestNewManager(t *testing.T) {
- expected := &Manager{
- callbacks: make(map[ftCrypto.TransferID][]*callbackTracker),
- stops: make(map[ftCrypto.TransferID]*stoppable.Multi),
- }
-
- newManager := NewManager()
-
- if !reflect.DeepEqual(expected, newManager) {
- t.Errorf("New Manager does not match expected."+
- "\nexpected: %+v\nreceived: %+v", expected, newManager)
- }
-}
-
-// Tests that Manager.AddCallback adds the callback to the list, creates and
-// adds a stoppable to the list, and that the callback is called.
-func TestManager_AddCallback(t *testing.T) {
- m := NewManager()
-
- cbChan := make(chan error, 10)
- cb := func(err error) { cbChan <- err }
- tid := &ftCrypto.TransferID{5}
- m.AddCallback(tid, cb, 0)
-
- // Check that the callback was called
- select {
- case <-cbChan:
- case <-time.After(25 * time.Millisecond):
- t.Error("Timed out waiting for callback to be called.")
- }
-
- // Check that the callback was added
- if _, exists := m.callbacks[*tid]; !exists {
- t.Errorf("No callback list found for transfer ID %s.", tid)
- } else if len(m.callbacks[*tid]) != 1 {
- t.Errorf("Incorrect number of callbacks.\nexpected: %d\nreceived: %d",
- 1, len(m.callbacks[*tid]))
- }
-
- // Check that the stoppable was added
- if _, exists := m.stops[*tid]; !exists {
- t.Errorf("No stoppable list found for transfer ID %s.", tid)
- }
-}
-
-// Tests that Manager.Call calls al the callbacks associated with the transfer
-// ID.
-func TestManager_Call(t *testing.T) {
- m := NewManager()
- tid := &ftCrypto.TransferID{5}
- n := 10
- cbChans := make([]chan error, n)
- cbs := make([]func(err error), n)
- for i := range cbChans {
- cbChan := make(chan error, 10)
- cbs[i] = func(err error) { cbChan <- err }
- cbChans[i] = cbChan
- }
-
- // Add callbacks
- for i := range cbs {
- m.AddCallback(tid, cbs[i], 0)
-
- // Receive channel from first call
- select {
- case <-cbChans[i]:
- case <-time.After(25 * time.Millisecond):
- t.Errorf("Callback #%d never called.", i)
- }
- }
-
- // Call callbacks
- m.Call(tid, errors.New("test"))
-
- // Check to make sure callbacks were called
- var wg sync.WaitGroup
- for i := range cbs {
- wg.Add(1)
- go func(i int) {
- select {
- case r := <-cbChans[i]:
- if r == nil {
- t.Errorf("Callback #%d did not receive an error.", i)
- }
- case <-time.After(25 * time.Millisecond):
- t.Errorf("Callback #%d never called.", i)
- }
-
- wg.Done()
- }(i)
- }
-
- wg.Wait()
-}
-
-// Tests that Manager.Delete removes all callbacks and stoppables from the list.
-func TestManager_Delete(t *testing.T) {
- m := NewManager()
-
- cbChan := make(chan error, 10)
- cb := func(err error) { cbChan <- err }
- tid := &ftCrypto.TransferID{5}
- m.AddCallback(tid, cb, 0)
-
- m.Delete(tid)
-
- // Check that the callback was deleted
- if _, exists := m.callbacks[*tid]; exists {
- t.Errorf("Callback list found for transfer ID %s.", tid)
- }
-
- // Check that the stoppable was deleted
- if _, exists := m.stops[*tid]; exists {
- t.Errorf("Stoppable list found for transfer ID %s.", tid)
- }
-}
-
-// Consistency test of makeStoppableName.
-func Test_makeStoppableName_Consistency(t *testing.T) {
- rng := NewPrng(42)
- expectedValues := []string{
- "U4x/lrFkvxuXu59LtHLon1sUhPJSCcnZND6SugndnVI=/0",
- "39ebTXZCm2F6DJ+fDTulWwzA1hRMiIU1hBrL4HCbB1g=/1",
- "CD9h03W8ArQd9PkZKeGP2p5vguVOdI6B555LvW/jTNw=/2",
- "uoQ+6NY+jE/+HOvqVG2PrBPdGqwEzi6ih3xVec+ix44=/3",
- "GwuvrogbgqdREIpC7TyQPKpDRlp4YgYWl4rtDOPGxPM=/4",
- "rnvD4ElbVxL+/b4MECiH4QDazS2IX2kstgfaAKEcHHA=/5",
- "ceeWotwtwlpbdLLhKXBeJz8FySMmgo4rBW44F2WOEGE=/6",
- "SYlH/fNEQQ7UwRYCP6jjV2tv7Sf/iXS6wMr9mtBWkrE=/7",
- "NhnnOJZN/ceejVNDc2Yc/WbXT+weG4lJGrcjbkt1IWI=/8",
- "kM8r60LDyicyhWDxqsBnzqbov0bUqytGgEAsX7KCDog=/9",
- }
-
- for i, expected := range expectedValues {
- tid, err := ftCrypto.NewTransferID(rng)
- if err != nil {
- t.Errorf("Failed to generated transfer ID #%d: %+v", i, err)
- }
-
- name := makeStoppableName(&tid, i)
- if expected != name {
- t.Errorf("Stoppable name does not match expected."+
- "\nexpected: %q\nreceived: %q", expected, name)
- }
- }
-}
-
-// Prng is a PRNG that satisfies the csprng.Source interface.
-type Prng struct{ prng io.Reader }
-
-func NewPrng(seed int64) csprng.Source { return &Prng{rand.New(rand.NewSource(seed))} }
-func (s *Prng) Read(b []byte) (int, error) { return s.prng.Read(b) }
-func (s *Prng) SetSeed([]byte) error { return nil }
diff --git a/fileTransfer2/delayedTimer.go b/fileTransfer2/delayedTimer.go
deleted file mode 100644
index 5f62cbc5c799623b9705a2395950eb5d954f2232..0000000000000000000000000000000000000000
--- a/fileTransfer2/delayedTimer.go
+++ /dev/null
@@ -1,56 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package fileTransfer2
-
-import "time"
-
-// The DelayedTimer type represents a single event manually started.
-// When the DelayedTimer expires, the current time will be sent on C.
-// A DelayedTimer must be created with NewDelayedTimer.
-type DelayedTimer struct {
- d time.Duration
- t *time.Timer
- C *<-chan time.Time
-}
-
-// NewDelayedTimer creates a new DelayedTimer that will send the current time on
-// its channel after at least duration d once it is started.
-func NewDelayedTimer(d time.Duration) *DelayedTimer {
- c := make(<-chan time.Time)
- return &DelayedTimer{
- d: d,
- C: &c,
- }
-}
-
-// Start starts the timer that will send the current time on its channel after
-// at least duration d. If it is already running or stopped, it does nothing.
-func (dt *DelayedTimer) Start() {
- if dt.t == nil {
- dt.t = time.NewTimer(dt.d)
- dt.C = &dt.t.C
- }
-}
-
-// Stop prevents the Timer from firing.
-// It returns true if the call stops the timer, false if the timer has already
-// expired, been stopped, or was never started.
-func (dt *DelayedTimer) Stop() bool {
- if dt.t == nil {
- return false
- }
-
- return dt.t.Stop()
-}
diff --git a/fileTransfer2/ftMessages.pb.go b/fileTransfer2/ftMessages.pb.go
deleted file mode 100644
index d4e4737335fd228bcae990ef2914248f9a6e31b3..0000000000000000000000000000000000000000
--- a/fileTransfer2/ftMessages.pb.go
+++ /dev/null
@@ -1,142 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: fileTransfer2/ftMessages.proto
-
-package fileTransfer2
-
-import (
- fmt "fmt"
- proto "github.com/golang/protobuf/proto"
- math "math"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
-
-// NewFileTransfer is transmitted first on the initialization of a file transfer
-// to inform the receiver about the incoming file.
-type NewFileTransfer struct {
- FileName string `protobuf:"bytes,1,opt,name=fileName,proto3" json:"fileName,omitempty"`
- FileType string `protobuf:"bytes,2,opt,name=fileType,proto3" json:"fileType,omitempty"`
- TransferKey []byte `protobuf:"bytes,3,opt,name=transferKey,proto3" json:"transferKey,omitempty"`
- TransferMac []byte `protobuf:"bytes,4,opt,name=transferMac,proto3" json:"transferMac,omitempty"`
- NumParts uint32 `protobuf:"varint,5,opt,name=numParts,proto3" json:"numParts,omitempty"`
- Size uint32 `protobuf:"varint,6,opt,name=size,proto3" json:"size,omitempty"`
- Retry float32 `protobuf:"fixed32,7,opt,name=retry,proto3" json:"retry,omitempty"`
- Preview []byte `protobuf:"bytes,8,opt,name=preview,proto3" json:"preview,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *NewFileTransfer) Reset() { *m = NewFileTransfer{} }
-func (m *NewFileTransfer) String() string { return proto.CompactTextString(m) }
-func (*NewFileTransfer) ProtoMessage() {}
-func (*NewFileTransfer) Descriptor() ([]byte, []int) {
- return fileDescriptor_7ae154b96911f608, []int{0}
-}
-
-func (m *NewFileTransfer) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_NewFileTransfer.Unmarshal(m, b)
-}
-func (m *NewFileTransfer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_NewFileTransfer.Marshal(b, m, deterministic)
-}
-func (m *NewFileTransfer) XXX_Merge(src proto.Message) {
- xxx_messageInfo_NewFileTransfer.Merge(m, src)
-}
-func (m *NewFileTransfer) XXX_Size() int {
- return xxx_messageInfo_NewFileTransfer.Size(m)
-}
-func (m *NewFileTransfer) XXX_DiscardUnknown() {
- xxx_messageInfo_NewFileTransfer.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_NewFileTransfer proto.InternalMessageInfo
-
-func (m *NewFileTransfer) GetFileName() string {
- if m != nil {
- return m.FileName
- }
- return ""
-}
-
-func (m *NewFileTransfer) GetFileType() string {
- if m != nil {
- return m.FileType
- }
- return ""
-}
-
-func (m *NewFileTransfer) GetTransferKey() []byte {
- if m != nil {
- return m.TransferKey
- }
- return nil
-}
-
-func (m *NewFileTransfer) GetTransferMac() []byte {
- if m != nil {
- return m.TransferMac
- }
- return nil
-}
-
-func (m *NewFileTransfer) GetNumParts() uint32 {
- if m != nil {
- return m.NumParts
- }
- return 0
-}
-
-func (m *NewFileTransfer) GetSize() uint32 {
- if m != nil {
- return m.Size
- }
- return 0
-}
-
-func (m *NewFileTransfer) GetRetry() float32 {
- if m != nil {
- return m.Retry
- }
- return 0
-}
-
-func (m *NewFileTransfer) GetPreview() []byte {
- if m != nil {
- return m.Preview
- }
- return nil
-}
-
-func init() {
- proto.RegisterType((*NewFileTransfer)(nil), "parse.NewFileTransfer")
-}
-
-func init() { proto.RegisterFile("fileTransfer2/ftMessages.proto", fileDescriptor_7ae154b96911f608) }
-
-var fileDescriptor_7ae154b96911f608 = []byte{
- // 215 bytes of a gzipped FileDescriptorProto
- 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x90, 0xbf, 0x4a, 0xc6, 0x30,
- 0x14, 0xc5, 0xc9, 0xe7, 0xd7, 0x3f, 0x46, 0x4b, 0x21, 0x38, 0x5c, 0x1c, 0x24, 0x38, 0x65, 0x52,
- 0xd0, 0x37, 0x70, 0x70, 0x91, 0x16, 0x09, 0x9d, 0xdc, 0x62, 0xb9, 0x95, 0x82, 0x6d, 0xc3, 0x4d,
- 0xb4, 0xd4, 0x77, 0xf6, 0x1d, 0xa4, 0xd1, 0xd6, 0x76, 0xcb, 0xef, 0x9c, 0x93, 0x73, 0xe1, 0xf0,
- 0xab, 0xa6, 0x7d, 0xc7, 0x8a, 0x4c, 0xef, 0x1a, 0xa4, 0xbb, 0xdb, 0xc6, 0x17, 0xe8, 0x9c, 0x79,
- 0x43, 0x77, 0x63, 0x69, 0xf0, 0x83, 0x88, 0xac, 0x21, 0x87, 0xd7, 0xdf, 0x8c, 0xe7, 0x25, 0x8e,
- 0x8f, 0x9b, 0xb0, 0xb8, 0xe4, 0xe9, 0xfc, 0xb9, 0x34, 0x1d, 0x02, 0x93, 0x4c, 0x9d, 0xea, 0x95,
- 0x17, 0xaf, 0x9a, 0x2c, 0xc2, 0xe1, 0xdf, 0x9b, 0x59, 0x48, 0x7e, 0xe6, 0xff, 0x3a, 0x9e, 0x70,
- 0x82, 0x13, 0xc9, 0xd4, 0xb9, 0xde, 0x4a, 0xdb, 0x44, 0x61, 0x6a, 0x38, 0xee, 0x13, 0x85, 0xa9,
- 0xe7, 0xfe, 0xfe, 0xa3, 0x7b, 0x36, 0xe4, 0x1d, 0x44, 0x92, 0xa9, 0x4c, 0xaf, 0x2c, 0x04, 0x3f,
- 0xba, 0xf6, 0x0b, 0x21, 0x0e, 0x7a, 0x78, 0x8b, 0x0b, 0x1e, 0x11, 0x7a, 0x9a, 0x20, 0x91, 0x4c,
- 0x1d, 0xf4, 0x2f, 0x08, 0xe0, 0x89, 0x25, 0xfc, 0x6c, 0x71, 0x84, 0x34, 0xdc, 0x58, 0xf0, 0x21,
- 0x7f, 0xc9, 0x76, 0xc3, 0xbc, 0xc6, 0x61, 0x8e, 0xfb, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x99,
- 0x46, 0x73, 0x93, 0x30, 0x01, 0x00, 0x00,
-}
diff --git a/fileTransfer2/ftMessages.proto b/fileTransfer2/ftMessages.proto
deleted file mode 100644
index 83b9f82c703b3c74ce0b07da4a4bb93cbd29e4f2..0000000000000000000000000000000000000000
--- a/fileTransfer2/ftMessages.proto
+++ /dev/null
@@ -1,24 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-///////////////////////////////////////////////////////////////////////////////
-
-syntax = "proto3";
-
-package parse;
-option go_package = "fileTransfer2";
-
-// NewFileTransfer is transmitted first on the initialization of a file transfer
-// to inform the receiver about the incoming file.
-message NewFileTransfer {
- string fileName = 1; // Name of the file
- string fileType = 2; // String that indicates type of file
- bytes transferKey = 3; // 256-bit encryption key
- bytes transferMac = 4; // 256-bit MAC of the entire file
- uint32 numParts = 5; // Number of file parts
- uint32 size = 6; // The size of the file, in bytes
- float retry = 7; // Determines how many times to retry sending
- bytes preview = 8; // A preview of the file
-}
\ No newline at end of file
diff --git a/fileTransfer2/generateProto.sh b/fileTransfer2/generateProto.sh
deleted file mode 100644
index 7f435f2df24ca2a878459bd0e99bb8b5b8a37e65..0000000000000000000000000000000000000000
--- a/fileTransfer2/generateProto.sh
+++ /dev/null
@@ -1,10 +0,0 @@
-#!/bin/bash
-
-#///////////////////////////////////////////////////////////////////////////////
-#/ Copyright © 2020 xx network SEZC //
-#/ //
-#/ Use of this source code is governed by a license that can be found in the //
-#/ LICENSE file //
-#///////////////////////////////////////////////////////////////////////////////
-
-protoc --go_out=paths=source_relative:. fileTransfer2/ftMessages.proto
diff --git a/fileTransfer2/interface.go b/fileTransfer2/interface.go
deleted file mode 100644
index b0fe8d5ac7137e08c72466865a68d1073f792c06..0000000000000000000000000000000000000000
--- a/fileTransfer2/interface.go
+++ /dev/null
@@ -1,275 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package fileTransfer2
-
-import (
- "gitlab.com/elixxir/client/stoppable"
- ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
- "gitlab.com/xx_network/primitives/id"
- "strconv"
- "time"
-)
-
-// SentProgressCallback is a callback function that tracks the progress of
-// sending a file.
-type SentProgressCallback func(completed bool, arrived, total uint16,
- st SentTransfer, t FilePartTracker, err error)
-
-// ReceivedProgressCallback is a callback function that tracks the progress of
-// receiving a file.
-type ReceivedProgressCallback func(completed bool, received, total uint16,
- rt ReceivedTransfer, t FilePartTracker, err error)
-
-// ReceiveCallback is a callback function that notifies the receiver of an
-// incoming file transfer.
-type ReceiveCallback func(tid *ftCrypto.TransferID, fileName, fileType string,
- sender *id.ID, size uint32, preview []byte)
-
-// SendNew handles the sending of the initial message informing the recipient
-// of the incoming file transfer parts. SendNew should block until the send
-// completes and return an error only on failed sends.
-type SendNew func(transferInfo []byte) error
-
-// FileTransfer facilities the sending and receiving of large file transfers.
-// It allows for progress tracking of both inbound and outbound transfers.
-// FileTransfer handles the sending of the file data; however, the caller is
-// responsible for communicating to the recipient of the incoming file transfer.
-type FileTransfer interface {
-
- // StartProcesses starts the sending threads that wait for file transfers to
- // send. Adheres to the xxdk.Service type.
- StartProcesses() (stoppable.Stoppable, error)
-
- // MaxFileNameLen returns the max number of bytes allowed for a file name.
- MaxFileNameLen() int
-
- // MaxFileTypeLen returns the max number of bytes allowed for a file type.
- MaxFileTypeLen() int
-
- // MaxFileSize returns the max number of bytes allowed for a file.
- MaxFileSize() int
-
- // MaxPreviewSize returns the max number of bytes allowed for a file
- // preview.
- MaxPreviewSize() int
-
- /* === Sending ========================================================== */
- /* The processes of sending a file involves four main steps:
- 1. Set up a method to send initial file transfer details using SendNew.
- 2. Sending the file using Send and register a progress callback.
- 3. Receiving transfer progress on the progress callback.
- 4. Closing a finished send using CloseSend.
-
- Once the file is sent, it is broken into individual, equal-length parts
- and sent to the recipient. Every time one of these parts arrives, it is
- reported on all registered SentProgressCallbacks for that transfer.
-
- A SentProgressCallback is registered on the initial send. However, if the
- client is closed and reopened, the callback must be registered again
- using RegisterSentProgressCallback, otherwise the continued progress of
- the transfer will not be reported.
-
- Once the SentProgressCallback returns that the file has completed
- sending, the file can be closed using CloseSend. If the callback reports
- an error, then the file should also be closed using CloseSend.
- */
-
- // Send initiates the sending of a file to the recipient and returns a
- // transfer ID that uniquely identifies this file transfer.
- //
- // In-progress transfers are restored when closing and reopening; however, a
- // SentProgressCallback must be registered again.
- //
- // recipient - ID of the receiver of the file transfer. The sender must
- // have an E2E relationship with the recipient.
- // fileName - Human-readable file name. Max length defined by
- // MaxFileNameLen.
- // fileType - Shorthand that identifies the type of file. Max length
- // defined by MaxFileTypeLen.
- // fileData - File contents. Max size defined by MaxFileSize.
- // retry - The number of sending retries allowed on send failure (e.g.
- // a retry of 2.0 with 6 parts means 12 total possible sends).
- // preview - A preview of the file data (e.g. a thumbnail). Max size
- // defined by MaxPreviewSize.
- // progressCB - A callback that reports the progress of the file transfer.
- // The callback is called once on initialization, on every progress
- // update (or less if restricted by the period), or on fatal error.
- // period - A progress callback will be limited from triggering only once
- // per period.
- // sendNew - Function that sends the file transfer information to the
- // recipient.
- Send(recipient *id.ID, fileName, fileType string, fileData []byte,
- retry float32, preview []byte, progressCB SentProgressCallback,
- period time.Duration, sendNew SendNew) (*ftCrypto.TransferID, error)
-
- // RegisterSentProgressCallback allows for the registration of a callback to
- // track the progress of an individual sent file transfer.
- // SentProgressCallback is auto registered on Send; this function should be
- // called when resuming clients or registering extra callbacks.
- //
- // The callback will be called immediately when added to report the current
- // progress of the transfer. It will then call every time a file part
- // arrives, the transfer completes, or a fatal error occurs. It is called at
- // most once every period regardless of the number of progress updates.
- //
- // In the event that the client is closed and resumed, this function must be
- // used to re-register any callbacks previously registered with this
- // function or Send.
- RegisterSentProgressCallback(tid *ftCrypto.TransferID,
- progressCB SentProgressCallback, period time.Duration) error
-
- // CloseSend deletes a file from the internal storage once a transfer has
- // completed or reached the retry limit. Returns an error if the transfer
- // has not run out of retries.
- //
- // This function should be called once a transfer completes or errors out
- // (as reported by the progress callback).
- CloseSend(tid *ftCrypto.TransferID) error
-
- /* === Receiving ======================================================== */
- /* The processes of receiving a file involves four main steps:
- 1. Receiving a new file transfer through a channel set up by the
- caller.
- 2. Registering the file transfer and a progress callback with
- HandleIncomingTransfer.
- 3. Receiving transfer progress on the progress callback.
- 4. Receiving the complete file using Receive once the callback says
- the transfer is complete.
-
- Once the file transfer manager has started, it will call the
- ReceiveCallback for every new file transfer that is received. Once that
- happens, a ReceivedProgressCallback must be registered using
- RegisterReceivedProgressCallback to get progress updates on the transfer.
-
- When the progress callback reports that the transfer is complete, the
- full file can be retrieved using Receive.
- */
-
- // HandleIncomingTransfer starts tracking the received file parts for the
- // given payload that contains the file transfer information and returns a
- // transfer ID that uniquely identifies this file transfer along with the
- // transfer information
- //
- // This function should be called once for every new file received on the
- // registered SendNew callback.
- //
- // In-progress transfers are restored when closing and reopening; however, a
- // ReceivedProgressCallback must be registered again.
- //
- // payload - A marshalled payload container the file transfer information.
- // progressCB - A callback that reports the progress of the file transfer.
- // The callback is called once on initialization, on every progress
- // update (or less if restricted by the period), or on fatal error.
- // period - A progress callback will be limited from triggering only once
- // per period.
- HandleIncomingTransfer(transferInfo []byte,
- progressCB ReceivedProgressCallback, period time.Duration) (
- *ftCrypto.TransferID, *TransferInfo, error)
-
- // RegisterReceivedProgressCallback allows for the registration of a
- // callback to track the progress of an individual received file transfer.
- // This should be done when a new transfer is received on the
- // ReceiveCallback.
- //
- // The callback will be called immediately when added to report the current
- // progress of the transfer. It will then call every time a file part is
- // received, the transfer completes, or a fatal error occurs. It is called
- // at most once every period regardless of the number of progress updates.
- //
- // In the event that the client is closed and resumed, this function must be
- // used to re-register any callbacks previously registered.
- //
- // Once the callback reports that the transfer has completed, the recipient
- // can get the full file by calling Receive.
- RegisterReceivedProgressCallback(tid *ftCrypto.TransferID,
- progressCB ReceivedProgressCallback, period time.Duration) error
-
- // Receive returns the full file on the completion of the transfer.
- // It deletes internal references to the data and unregisters any attached
- // progress callback. Returns an error if the transfer is not complete, the
- // full file cannot be verified, or if the transfer cannot be found.
- //
- // Receive can only be called once the progress callback returns that the
- // file transfer is complete.
- Receive(tid *ftCrypto.TransferID) ([]byte, error)
-}
-
-// SentTransfer tracks the information and individual parts of a sent file
-// transfer.
-type SentTransfer interface {
- Recipient() *id.ID
- Transfer
-}
-
-// ReceivedTransfer tracks the information and individual parts of a received
-// file transfer.
-type ReceivedTransfer interface {
- Transfer
-}
-
-// Transfer is the generic structure for a file transfer.
-type Transfer interface {
- TransferID() *ftCrypto.TransferID
- FileName() string
- FileSize() uint32
- NumParts() uint16
-}
-
-// FilePartTracker tracks the status of each file part in a sent or received
-// file transfer.
-type FilePartTracker interface {
- // GetPartStatus returns the status of the file part with the given part
- // number. The possible values for the status are:
- // 0 < Part does not exist
- // 0 = unsent
- // 1 = arrived (sender has sent a part, and it has arrived)
- // 2 = received (receiver has received a part)
- GetPartStatus(partNum uint16) FpStatus
-
- // GetNumParts returns the total number of file parts in the transfer.
- GetNumParts() uint16
-}
-
-// FpStatus is the file part status and indicates the status of individual file
-// parts in a file transfer.
-type FpStatus int
-
-// Possible values for FpStatus.
-const (
- // FpUnsent indicates that the file part has not been sent
- FpUnsent FpStatus = iota
-
- // FpSent indicates that the file part has been sent (sender has sent a
- // part, but it has not arrived)
- FpSent
-
- // FpArrived indicates that the file part has arrived (sender has sent a
- // part, and it has arrived)
- FpArrived
-
- // FpReceived indicates that the file part has been received (receiver has
- // received a part)
- FpReceived
-)
-
-// String returns the string representing of the FpStatus. This functions
-// satisfies the fmt.Stringer interface.
-func (fps FpStatus) String() string {
- switch fps {
- case FpUnsent:
- return "unsent"
- case FpSent:
- return "sent"
- case FpArrived:
- return "arrived"
- case FpReceived:
- return "received"
- default:
- return "INVALID FpStatus: " + strconv.Itoa(int(fps))
- }
-}
diff --git a/fileTransfer2/manager.go b/fileTransfer2/manager.go
deleted file mode 100644
index 76cd42ffbce8eec07a2b274b1bfa54a4d2703ba8..0000000000000000000000000000000000000000
--- a/fileTransfer2/manager.go
+++ /dev/null
@@ -1,573 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package fileTransfer2
-
-import (
- "bytes"
- "github.com/pkg/errors"
- jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/client/cmix"
- "gitlab.com/elixxir/client/cmix/message"
- "gitlab.com/elixxir/client/fileTransfer2/callbackTracker"
- "gitlab.com/elixxir/client/fileTransfer2/store"
- "gitlab.com/elixxir/client/fileTransfer2/store/fileMessage"
- "gitlab.com/elixxir/client/stoppable"
- "gitlab.com/elixxir/client/storage/versioned"
- "gitlab.com/elixxir/crypto/cyclic"
- "gitlab.com/elixxir/crypto/fastRNG"
- ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
- "gitlab.com/elixxir/primitives/format"
- "gitlab.com/xx_network/primitives/id"
- "gitlab.com/xx_network/primitives/id/ephemeral"
- "time"
-)
-
-const (
- // FileNameMaxLen is the maximum size, in bytes, for a file name. Currently,
- // it is set to 48 bytes.
- FileNameMaxLen = 48
-
- // FileTypeMaxLen is the maximum size, in bytes, for a file type. Currently,
- // it is set to 8 bytes.
- FileTypeMaxLen = 8
-
- // FileMaxSize is the maximum file size that can be transferred. Currently,
- // it is set to 250 kB.
- FileMaxSize = 250_000
-
- // PreviewMaxSize is the maximum size, in bytes, for a file preview.
- // Currently, it is set to 4 kB.
- PreviewMaxSize = 4_000
-
- // minPartsSendPerRound is the minimum number of file parts sent each round.
- minPartsSendPerRound = 1
-
- // maxPartsSendPerRound is the maximum number of file parts sent each round.
- maxPartsSendPerRound = 11
-
- // Size of the buffered channel that queues file parts to package
- batchQueueBuffLen = 10_000
-
- // Size of the buffered channel that queues file packets to send
- sendQueueBuffLen = 10_000
-)
-
-// Stoppable and listener values.
-const (
- fileTransferStoppable = "FileTransfer"
- workerPoolStoppable = "FilePartSendingWorkerPool"
- batchBuilderThreadStoppable = "BatchBuilderThread"
-)
-
-// Error messages.
-const (
- errNoSentTransfer = "could not find sent transfer with ID %s"
- errNoReceivedTransfer = "could not find received transfer with ID %s"
-
- // NewManager
- errNewOrLoadSent = "failed to load or create new list of sent file transfers: %+v"
- errNewOrLoadReceived = "failed to load or create new list of received file transfers: %+v"
-
- // manager.Send
- errFileNameSize = "length of filename (%d) greater than max allowed length (%d)"
- errFileTypeSize = "length of file type (%d) greater than max allowed length (%d)"
- errFileSize = "size of file (%d bytes) greater than max allowed size (%d bytes)"
- errPreviewSize = "size of preview (%d bytes) greater than max allowed size (%d bytes)"
- errSendNetworkHealth = "cannot initiate file transfer of %q when network is not healthy."
- errNewKey = "could not generate new transfer key: %+v"
- errNewID = "could not generate new transfer ID: %+v"
- errMarshalInfo = "could not marshal transfer info: %+v"
- errSendNewMsg = "failed to send initial file transfer message: %+v"
- errAddSentTransfer = "failed to add transfer: %+v"
-
- // manager.CloseSend
- errDeleteIncompleteTransfer = "cannot delete transfer %s that has not completed or failed"
- errDeleteSentTransfer = "could not delete sent transfer %s: %+v"
- errRemoveSentTransfer = "could not remove transfer %s from list: %+v"
-
- // manager.HandleIncomingTransfer
- errNewRtTransferID = "failed to generate transfer ID for new received file transfer %q: %+v"
- errAddNewRt = "failed to add new file transfer %s (%q): %+v"
-
- // manager.Receive
- errIncompleteFile = "cannot get incomplete file: missing %d of %d parts"
- errDeleteReceivedTransfer = "could not delete received transfer %s: %+v"
- errRemoveReceivedTransfer = "could not remove transfer %s from list: %+v"
-)
-
-// manager handles the sending and receiving of file, their storage, and their
-// callbacks.
-type manager struct {
- // Storage-backed structure for tracking sent file transfers
- sent *store.Sent
-
- // Storage-backed structure for tracking received file transfers
- received *store.Received
-
- // Progress callback tracker
- callbacks *callbackTracker.Manager
-
- // Queue of parts to batch and send
- batchQueue chan store.Part
-
- // Queue of batches of parts to send
- sendQueue chan []store.Part
-
- // File transfer parameters
- params Params
-
- myID *id.ID
- cmix Cmix
- cmixGroup *cyclic.Group
- kv *versioned.KV
- rng *fastRNG.StreamGenerator
-}
-
-// Cmix interface matches a subset of the cmix.Client methods used by the
-// manager for easier testing.
-type Cmix interface {
- GetMaxMessageLength() int
- SendMany(messages []cmix.TargetedCmixMessage, p cmix.CMIXParams) (id.Round,
- []ephemeral.Id, error)
- AddFingerprint(identity *id.ID, fingerprint format.Fingerprint,
- mp message.Processor) error
- DeleteFingerprint(identity *id.ID, fingerprint format.Fingerprint)
- CheckInProgressMessages()
- IsHealthy() bool
- AddHealthCallback(f func(bool)) uint64
- RemoveHealthCallback(uint64)
- GetRoundResults(timeout time.Duration,
- roundCallback cmix.RoundEventCallback, roundList ...id.Round) error
-}
-
-// Storage interface matches a subset of the storage.Session methods used by the
-// manager for easier testing.
-type Storage interface {
- GetKV() *versioned.KV
- GetCmixGroup() *cyclic.Group
-}
-
-// NewManager creates a new file transfer manager object. If sent or received
-// transfers already existed, they are loaded from storage and queued to resume
-// once manager.startProcesses is called.
-func NewManager(params Params, myID *id.ID, cmix Cmix, storage Storage,
- rng *fastRNG.StreamGenerator) (FileTransfer, error) {
- kv := storage.GetKV()
-
- // Create a new list of sent file transfers or load one if it exists
- sent, unsentParts, err := store.NewOrLoadSent(kv)
- if err != nil {
- return nil, errors.Errorf(errNewOrLoadSent, err)
- }
-
- // Create a new list of received file transfers or load one if it exists
- received, incompleteTransfers, err := store.NewOrLoadReceived(kv)
- if err != nil {
- return nil, errors.Errorf(errNewOrLoadReceived, err)
- }
-
- // Construct manager
- m := &manager{
- sent: sent,
- received: received,
- callbacks: callbackTracker.NewManager(),
- batchQueue: make(chan store.Part, batchQueueBuffLen),
- sendQueue: make(chan []store.Part, sendQueueBuffLen),
- params: params,
- myID: myID,
- cmix: cmix,
- cmixGroup: storage.GetCmixGroup(),
- kv: kv,
- rng: rng,
- }
-
- // Add all unsent file parts to queue
- for _, p := range unsentParts {
- m.batchQueue <- p
- }
-
- // Add all fingerprints for unreceived parts
- for _, rt := range incompleteTransfers {
- m.addFingerprints(rt)
- }
-
- return m, nil
-}
-
-// StartProcesses starts the sending threads. Adheres to the xxdk.Service type.
-func (m *manager) StartProcesses() (stoppable.Stoppable, error) {
- // Construct stoppables
- multiStop := stoppable.NewMulti(workerPoolStoppable)
- batchBuilderStop := stoppable.NewSingle(batchBuilderThreadStoppable)
-
- // Start sending threads
- go m.startSendingWorkerPool(multiStop)
- go m.batchBuilderThread(batchBuilderStop)
-
- // Create a multi stoppable
- multiStoppable := stoppable.NewMulti(fileTransferStoppable)
- multiStoppable.Add(multiStop)
- multiStoppable.Add(batchBuilderStop)
-
- return multiStoppable, nil
-}
-
-// MaxFileNameLen returns the max number of bytes allowed for a file name.
-func (m *manager) MaxFileNameLen() int {
- return FileNameMaxLen
-}
-
-// MaxFileTypeLen returns the max number of bytes allowed for a file type.
-func (m *manager) MaxFileTypeLen() int {
- return FileTypeMaxLen
-}
-
-// MaxFileSize returns the max number of bytes allowed for a file.
-func (m *manager) MaxFileSize() int {
- return FileMaxSize
-}
-
-// MaxPreviewSize returns the max number of bytes allowed for a file preview.
-func (m *manager) MaxPreviewSize() int {
- return PreviewMaxSize
-}
-
-/* === Sending ============================================================== */
-
-// Send partitions the given file into cMix message sized chunks and sends them
-// via cmix.SendMany.
-func (m *manager) Send(recipient *id.ID, fileName, fileType string,
- fileData []byte, retry float32, preview []byte,
- progressCB SentProgressCallback, period time.Duration, sendNew SendNew) (
- *ftCrypto.TransferID, error) {
-
- // Return an error if the file name is too long
- if len(fileName) > FileNameMaxLen {
- return nil, errors.Errorf(errFileNameSize, len(fileName), FileNameMaxLen)
- }
-
- // Return an error if the file type is too long
- if len(fileType) > FileTypeMaxLen {
- return nil, errors.Errorf(errFileTypeSize, len(fileType), FileTypeMaxLen)
- }
-
- // Return an error if the file is too large
- if len(fileData) > FileMaxSize {
- return nil, errors.Errorf(errFileSize, len(fileData), FileMaxSize)
- }
-
- // Return an error if the preview is too large
- if len(preview) > PreviewMaxSize {
- return nil, errors.Errorf(errPreviewSize, len(preview), PreviewMaxSize)
- }
-
- // Return an error if the network is not healthy
- if !m.cmix.IsHealthy() {
- return nil, errors.Errorf(errSendNetworkHealth, fileName)
- }
-
- // Generate new transfer key and transfer ID
- rng := m.rng.GetStream()
- key, err := ftCrypto.NewTransferKey(rng)
- if err != nil {
- rng.Close()
- return nil, errors.Errorf(errNewKey, err)
- }
- tid, err := ftCrypto.NewTransferID(rng)
- if err != nil {
- rng.Close()
- return nil, errors.Errorf(errNewID, err)
- }
- rng.Close()
-
- // Generate transfer MAC
- mac := ftCrypto.CreateTransferMAC(fileData, key)
-
- // Get size of each part and partition file into equal length parts
- partMessage := fileMessage.NewPartMessage(m.cmix.GetMaxMessageLength())
- parts := partitionFile(fileData, partMessage.GetPartSize())
- numParts := uint16(len(parts))
- fileSize := uint32(len(fileData))
-
- // Send the initial file transfer message over E2E
- info := &TransferInfo{
- fileName, fileType, key, mac, numParts, fileSize, retry, preview}
- transferInfo, err := info.Marshal()
- if err != nil {
- return nil, errors.Errorf(errMarshalInfo, err)
- }
- err = sendNew(transferInfo)
- if err != nil {
- return nil, errors.Errorf(errSendNewMsg, err)
- }
-
- // Calculate the number of fingerprints to generate
- numFps := calcNumberOfFingerprints(len(parts), retry)
-
- // Create new sent transfer
- st, err := m.sent.AddTransfer(
- recipient, &key, &tid, fileName, fileSize, parts, numFps)
- if err != nil {
- return nil, errors.Errorf(errAddSentTransfer, err)
- }
-
- // Add all parts to the send queue
- for _, p := range st.GetUnsentParts() {
- m.batchQueue <- p
- }
-
- // Register the progress callback
- m.registerSentProgressCallback(st, progressCB, period)
-
- return &tid, nil
-}
-
-// RegisterSentProgressCallback adds the given callback to the callback manager
-// for the given transfer ID. Returns an error if the transfer cannot be found.
-func (m *manager) RegisterSentProgressCallback(tid *ftCrypto.TransferID,
- progressCB SentProgressCallback, period time.Duration) error {
- st, exists := m.sent.GetTransfer(tid)
- if !exists {
- return errors.Errorf(errNoSentTransfer, tid)
- }
-
- m.registerSentProgressCallback(st, progressCB, period)
-
- return nil
-}
-
-// registerSentProgressCallback creates a callback for the sent transfer that
-// will get the most recent progress and send it on the progress callback.
-func (m *manager) registerSentProgressCallback(st *store.SentTransfer,
- progressCB SentProgressCallback, period time.Duration) {
- if progressCB == nil {
- return
- }
-
- // Build callback
- cb := func(err error) {
- // Get transfer progress
- arrived, total := st.NumArrived(), st.NumParts()
- completed := arrived == total
-
- // Build part tracker from copy of part statuses vector
- tracker := &sentFilePartTracker{st.CopyPartStatusVector()}
-
- // Call the progress callback
- progressCB(completed, arrived, total, st, tracker, err)
- }
-
- // Add the callback to the callback tracker
- m.callbacks.AddCallback(st.TransferID(), cb, period)
-}
-
-// CloseSend deletes the sent transfer from storage and the sent transfer list.
-// Also stops any scheduled progress callbacks and deletes them from the manager
-// to prevent any further calls. Deletion only occurs if the transfer has either
-// completed or failed.
-func (m *manager) CloseSend(tid *ftCrypto.TransferID) error {
- st, exists := m.sent.GetTransfer(tid)
- if !exists {
- return errors.Errorf(errNoSentTransfer, tid)
- }
-
- // Check that the transfer is either completed or failed
- if st.Status() != store.Completed && st.Status() != store.Failed {
- return errors.Errorf(errDeleteIncompleteTransfer, tid)
- }
-
- // Delete from storage
- err := st.Delete()
- if err != nil {
- return errors.Errorf(errDeleteSentTransfer, tid, err)
- }
-
- // Delete from transfers list
- err = m.sent.RemoveTransfer(tid)
- if err != nil {
- return errors.Errorf(errRemoveSentTransfer, tid, err)
- }
-
- // Stop and delete all progress callbacks
- m.callbacks.Delete(tid)
-
- return nil
-}
-
-/* === Receiving ============================================================ */
-
-const errUnmarshalInfo = "failed to unmarshal incoming transfer info: %+v"
-
-// HandleIncomingTransfer starts tracking the received file parts for the given
-// file information and returns a transfer ID that uniquely identifies this file
-// transfer.
-func (m *manager) HandleIncomingTransfer(transferInfo []byte,
- progressCB ReceivedProgressCallback, period time.Duration) (
- *ftCrypto.TransferID, *TransferInfo, error) {
-
- // Unmarshal the payload
- t, err := UnmarshalTransferInfo(transferInfo)
- if err != nil {
- return nil, nil, errors.Errorf(errUnmarshalInfo, err)
- }
-
- // Generate new transfer ID
- rng := m.rng.GetStream()
- tid, err := ftCrypto.NewTransferID(rng)
- if err != nil {
- rng.Close()
- return nil, nil, errors.Errorf(errNewRtTransferID, t.FileName, err)
- }
- rng.Close()
-
- // Calculate the number of fingerprints based on the retry rate
- numFps := calcNumberOfFingerprints(int(t.NumParts), t.Retry)
-
- // Store the transfer
- rt, err := m.received.AddTransfer(
- &t.Key, &tid, t.FileName, t.Mac, t.Size, t.NumParts, numFps)
- if err != nil {
- return nil, nil, errors.Errorf(errAddNewRt, tid, t.FileName, err)
- }
-
- // Start tracking fingerprints for each file part
- m.addFingerprints(rt)
-
- // Register the progress callback
- m.registerReceivedProgressCallback(rt, progressCB, period)
-
- return &tid, t, nil
-}
-
-// Receive concatenates the received file and returns it. Only returns the file
-// if all file parts have been received and returns an error otherwise. Also
-// deletes the transfer from storage. Once Receive has been called on a file, it
-// cannot be received again.
-func (m *manager) Receive(tid *ftCrypto.TransferID) ([]byte, error) {
- rt, exists := m.received.GetTransfer(tid)
- if !exists {
- return nil, errors.Errorf(errNoReceivedTransfer, tid)
- }
-
- // Return an error if the transfer is not complete
- if rt.NumReceived() != rt.NumParts() {
- return nil, errors.Errorf(
- errIncompleteFile, rt.NumParts()-rt.NumReceived(), rt.NumParts())
- }
-
- // Get the file
- file := rt.GetFile()
-
- // Delete all unused fingerprints
- for _, c := range rt.GetUnusedCyphers() {
- m.cmix.DeleteFingerprint(m.myID, c.GetFingerprint())
- }
-
- // Delete from storage
- err := rt.Delete()
- if err != nil {
- return nil, errors.Errorf(errDeleteReceivedTransfer, tid, err)
- }
-
- // Delete from transfers list
- err = m.received.RemoveTransfer(tid)
- if err != nil {
- return nil, errors.Errorf(errRemoveReceivedTransfer, tid, err)
- }
-
- // Stop and delete all progress callbacks
- m.callbacks.Delete(tid)
-
- return file, nil
-}
-
-// RegisterReceivedProgressCallback adds the given callback to the callback
-// manager for the given transfer ID. Returns an error if the transfer cannot be
-// found.
-func (m *manager) RegisterReceivedProgressCallback(tid *ftCrypto.TransferID,
- progressCB ReceivedProgressCallback, period time.Duration) error {
- rt, exists := m.received.GetTransfer(tid)
- if !exists {
- return errors.Errorf(errNoReceivedTransfer, tid)
- }
-
- m.registerReceivedProgressCallback(rt, progressCB, period)
-
- return nil
-}
-
-// registerReceivedProgressCallback creates a callback for the received transfer
-// that will get the most recent progress and send it on the progress callback.
-func (m *manager) registerReceivedProgressCallback(rt *store.ReceivedTransfer,
- progressCB ReceivedProgressCallback, period time.Duration) {
- if progressCB == nil {
- return
- }
-
- // Build callback
- cb := func(err error) {
- // Get transfer progress
- received, total := rt.NumReceived(), rt.NumParts()
- completed := received == total
-
- // Build part tracker from copy of part statuses vector
- tracker := &receivedFilePartTracker{rt.CopyPartStatusVector()}
-
- // Call the progress callback
- progressCB(completed, received, total, rt, tracker, err)
- }
-
- // Add the callback to the callback tracker
- m.callbacks.AddCallback(rt.TransferID(), cb, period)
-}
-
-/* === Utility ============================================================== */
-
-// partitionFile splits the file into parts of the specified part size.
-func partitionFile(file []byte, partSize int) [][]byte {
- // Initialize part list to the correct size
- numParts := (len(file) + partSize - 1) / partSize
- parts := make([][]byte, 0, numParts)
- buff := bytes.NewBuffer(file)
-
- for n := buff.Next(partSize); len(n) > 0; n = buff.Next(partSize) {
- newPart := make([]byte, partSize)
- copy(newPart, n)
- parts = append(parts, newPart)
- }
-
- return parts
-}
-
-// calcNumberOfFingerprints is the formula used to calculate the number of
-// fingerprints to generate, which is based off the number of file parts and the
-// retry float.
-func calcNumberOfFingerprints(numParts int, retry float32) uint16 {
- return uint16(float32(numParts) * (1 + retry))
-}
-
-// addFingerprints adds all fingerprints for unreceived parts in the received
-// transfer.
-func (m *manager) addFingerprints(rt *store.ReceivedTransfer) {
- // Build processor for each file part and add its fingerprint to receive on
- for _, c := range rt.GetUnusedCyphers() {
- p := &processor{
- Cypher: c,
- ReceivedTransfer: rt,
- manager: m,
- }
-
- err := m.cmix.AddFingerprint(m.myID, c.GetFingerprint(), p)
- if err != nil {
- jww.ERROR.Printf("[FT] Failed to add fingerprint for transfer "+
- "%s: %+v", rt.TransferID(), err)
- }
- }
-
- m.cmix.CheckInProgressMessages()
-}
diff --git a/fileTransfer2/manager_test.go b/fileTransfer2/manager_test.go
deleted file mode 100644
index d9827a5436d58c3da762ec8396524d6b48ffa1c4..0000000000000000000000000000000000000000
--- a/fileTransfer2/manager_test.go
+++ /dev/null
@@ -1,564 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package fileTransfer2
-
-import (
- "bytes"
- "gitlab.com/elixxir/client/cmix"
- "gitlab.com/elixxir/client/storage"
- "gitlab.com/elixxir/crypto/fastRNG"
- "gitlab.com/xx_network/crypto/csprng"
- "gitlab.com/xx_network/primitives/id"
- "gitlab.com/xx_network/primitives/netTime"
- "math"
- "math/rand"
- "reflect"
- "sync"
- "sync/atomic"
- "testing"
- "time"
-)
-
-// Tests that manager adheres to the FileTransfer interface.
-var _ FileTransfer = (*manager)(nil)
-
-// Tests that Cmix adheres to the cmix.Client interface.
-var _ Cmix = (cmix.Client)(nil)
-
-// Tests that Storage adheres to the storage.Session interface.
-var _ Storage = (storage.Session)(nil)
-
-// Tests that partitionFile partitions the given file into the expected parts.
-func Test_partitionFile(t *testing.T) {
- prng := rand.New(rand.NewSource(42))
- partSize := 96
- fileData, expectedParts := newFile(24, partSize, prng, t)
-
- receivedParts := partitionFile(fileData, partSize)
-
- if !reflect.DeepEqual(expectedParts, receivedParts) {
- t.Errorf("File parts do not match expected."+
- "\nexpected: %q\nreceived: %q", expectedParts, receivedParts)
- }
-
- fullFile := bytes.Join(receivedParts, nil)
- if !bytes.Equal(fileData, fullFile) {
- t.Errorf("Full file does not match expected."+
- "\nexpected: %q\nreceived: %q", fileData, fullFile)
- }
-}
-
-// Tests that calcNumberOfFingerprints matches some manually calculated results.
-func Test_calcNumberOfFingerprints(t *testing.T) {
- testValues := []struct {
- numParts int
- retry float32
- result uint16
- }{
- {12, 0.5, 18},
- {13, 0.6667, 21},
- {1, 0.89, 1},
- {2, 0.75, 3},
- {119, 0.45, 172},
- }
-
- for i, val := range testValues {
- result := calcNumberOfFingerprints(val.numParts, val.retry)
-
- if val.result != result {
- t.Errorf("calcNumberOfFingerprints(%3d, %3.2f) result is "+
- "incorrect (%d).\nexpected: %d\nreceived: %d",
- val.numParts, val.retry, i, val.result, result)
- }
- }
-}
-
-// Smoke test of the entire file transfer system.
-func Test_FileTransfer_Smoke(t *testing.T) {
- // jww.SetStdoutThreshold(jww.LevelDebug)
- // Set up cMix and E2E message handlers
- cMixHandler := newMockCmixHandler()
- rngGen := fastRNG.NewStreamGenerator(1000, 10, csprng.NewSystemRNG)
- params := DefaultParams()
- // params.MaxThroughput = math.MaxInt
- // params.MaxThroughput = 0
-
- // Set up the first client
- myID1 := id.NewIdFromString("myID1", id.User, t)
- storage1 := newMockStorage()
- ftm1, err := NewManager(params, myID1,
- newMockCmix(myID1, cMixHandler, storage1), storage1, rngGen)
- if err != nil {
- t.Errorf("Failed to create new file transfer manager 1: %+v", err)
- }
- m1 := ftm1.(*manager)
-
- stop1, err := m1.StartProcesses()
- if err != nil {
- t.Errorf("Failed to start processes for manager 1: %+v", err)
- }
-
- // Set up the second client
- myID2 := id.NewIdFromString("myID2", id.User, t)
- storage2 := newMockStorage()
- ftm2, err := NewManager(params, myID2,
- newMockCmix(myID2, cMixHandler, storage2), storage2, rngGen)
- if err != nil {
- t.Errorf("Failed to create new file transfer manager 2: %+v", err)
- }
- m2 := ftm2.(*manager)
-
- stop2, err := m2.StartProcesses()
- if err != nil {
- t.Errorf("Failed to start processes for manager 2: %+v", err)
- }
-
- sendNewCbChan1 := make(chan []byte)
- sendNewCb1 := func(transferInfo []byte) error {
- sendNewCbChan1 <- transferInfo
- return nil
- }
-
- // Wait group prevents the test from quiting before the file has completed
- // sending and receiving
- var wg sync.WaitGroup
-
- // Define details of file to send
- fileName, fileType := "myFile", "txt"
- fileData := []byte(loremIpsum)
- preview := []byte("Lorem ipsum dolor sit amet")
- retry := float32(2.0)
-
- // Create go func that waits for file transfer to be received to register
- // a progress callback that then checks that the file received is correct
- // when done
- wg.Add(1)
- called := uint32(0)
- timeReceived := make(chan time.Time)
- go func() {
- select {
- case r := <-sendNewCbChan1:
- tid, _, err := m2.HandleIncomingTransfer(r, nil, 0)
- if err != nil {
- t.Errorf("Failed to add transfer: %+v", err)
- }
- receiveProgressCB := func(completed bool, received, total uint16,
- rt ReceivedTransfer, fpt FilePartTracker, err error) {
- if completed && atomic.CompareAndSwapUint32(&called, 0, 1) {
- timeReceived <- netTime.Now()
- receivedFile, err2 := m2.Receive(tid)
- if err2 != nil {
- t.Errorf("Failed to receive file: %+v", err2)
- }
-
- if !bytes.Equal(fileData, receivedFile) {
- t.Errorf("Received file does not match sent."+
- "\nsent: %q\nreceived: %q",
- fileData, receivedFile)
- }
- wg.Done()
- }
- }
- err3 := m2.RegisterReceivedProgressCallback(
- tid, receiveProgressCB, 0)
- if err3 != nil {
- t.Errorf(
- "Failed to Rregister received progress callback: %+v", err3)
- }
- case <-time.After(2100 * time.Millisecond):
- t.Errorf("Timed out waiting to receive new file transfer.")
- wg.Done()
- }
- }()
-
- // Define sent progress callback
- wg.Add(1)
- sentProgressCb1 := func(completed bool, arrived, total uint16,
- st SentTransfer, fpt FilePartTracker, err error) {
- if completed {
- wg.Done()
- }
- }
-
- // Send file.
- sendStart := netTime.Now()
- tid1, err := m1.Send(myID2, fileName, fileType, fileData, retry, preview,
- sentProgressCb1, 0, sendNewCb1)
- if err != nil {
- t.Errorf("Failed to send file: %+v", err)
- }
-
- go func() {
- select {
- case tr := <-timeReceived:
- fileSize := len(fileData)
- sendTime := tr.Sub(sendStart)
- fileSizeKb := float64(fileSize) * .001
- throughput := fileSizeKb * float64(time.Second) / (float64(sendTime))
- t.Logf("Completed receiving file %q in %s (%.2f kb @ %.2f kb/s).",
- fileName, sendTime, fileSizeKb, throughput)
-
- expectedThroughput := float64(params.MaxThroughput) * .001
- delta := (math.Abs(expectedThroughput-throughput) / ((expectedThroughput + throughput) / 2)) * 100
- t.Logf("Expected bandwidth: %.2f kb/s", expectedThroughput)
- t.Logf("Bandwidth difference: %.2f kb/s (%.2f%%)", expectedThroughput-throughput, delta)
- }
- }()
-
- // Wait for file to be sent and received
- wg.Wait()
-
- err = m1.CloseSend(tid1)
- if err != nil {
- t.Errorf("Failed to close transfer: %+v", err)
- }
-
- err = stop1.Close()
- if err != nil {
- t.Errorf("Failed to close processes for manager 1: %+v", err)
- }
-
- err = stop2.Close()
- if err != nil {
- t.Errorf("Failed to close processes for manager 2: %+v", err)
- }
-}
-
-const loremIpsum = `Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut at efficitur urna, et ultrices leo. Sed lacinia vestibulum tortor eu convallis. Proin imperdiet accumsan magna, sed volutpat tortor consectetur at. Mauris sed dolor sed sapien porta consectetur in eu sem. Maecenas vestibulum varius erat, eget porta eros vehicula mattis. Phasellus tempor odio at tortor maximus convallis. Nullam ut lorem laoreet, tincidunt ex sollicitudin, aliquam urna. Mauris vel enim consequat, sodales nibh quis, sollicitudin ipsum. Quisque lacinia, sapien a tempor eleifend, dolor nibh posuere neque, sit amet tempus dolor ante non nunc. Proin tempor blandit mollis. Mauris nunc sem, egestas eget velit ut, luctus molestie ipsum. Pellentesque sed eleifend dolor. Nullam pulvinar dignissim ante, eget luctus quam hendrerit vel. Proin ornare non tortor vitae rhoncus. Etiam tellus sem, condimentum id bibendum sed, blandit ac lorem. Maecenas gravida, neque quis blandit ultrices, nisl elit pretium nulla, ac volutpat massa odio sed arcu.
-
-Etiam at nibh dui. Vestibulum eget odio vestibulum sapien volutpat facilisis. Phasellus tempor risus in nisi viverra, ut porta est dictum. Aliquam in urna gravida, pulvinar sem ac, luctus erat. Fusce posuere id mauris non placerat. Quisque porttitor sagittis sapien nec scelerisque. Aenean sed mi nec ante tincidunt maximus. Etiam accumsan, dui eget varius mattis, ex quam efficitur est, id ornare nulla orci id mi. Mauris vulputate tincidunt nunc, et tempor augue sollicitudin eget.
-
-Sed vitae commodo neque, euismod finibus libero. Integer eget condimentum elit, id volutpat odio. Donec convallis magna lacus, varius volutpat augue lacinia a. Proin venenatis ex et ullamcorper faucibus. Nulla scelerisque, mauris id molestie hendrerit, magna justo faucibus lacus, quis convallis nulla lorem nec nisi. Nunc dictum nisi a molestie efficitur. Etiam vel nibh sit amet nibh finibus gravida eget id tellus. Donec elementum blandit molestie. Donec fringilla sapien ut neque bibendum, at ultrices dui molestie. Sed lobortis auctor justo at tincidunt. In vitae velit augue. Vestibulum pharetra ex quam, in vehicula urna ullamcorper sit amet. Phasellus at rhoncus diam, nec interdum ligula. Pellentesque eget risus dictum, ultrices velit at, fermentum justo. Nulla orci ex, tempor vitae velit eu, gravida pellentesque dolor.
-
-Aenean auctor at lorem in auctor. Sed at mi non quam aliquam aliquet vitae eu erat. Sed eu orci ac elit scelerisque rhoncus eget at orci. Donec a imperdiet ipsum. Phasellus efficitur lobortis mauris, et scelerisque diam consectetur sit amet. Nunc nunc lectus, accumsan vel eleifend vel, tempor vitae sapien. Nunc dictum tempus turpis non blandit. Sed condimentum pretium velit ac sodales. In accumsan leo vel sem commodo, eget hendrerit risus interdum. Nullam quis malesuada purus, non euismod turpis. In augue lorem, convallis quis urna vel, euismod tincidunt nunc. Ut eget luctus lacus, in commodo diam.
-
-Aenean ut ante sed ex ornare maximus quis venenatis urna. Fusce commodo fermentum velit nec varius. Etiam vitae odio vel nisl condimentum fringilla. Donec in risus tincidunt ex placerat vestibulum. Donec hendrerit tellus convallis malesuada vulputate. Aenean condimentum metus id est mollis viverra. Quisque at auctor turpis. Aenean est metus, laoreet eu justo a, consequat suscipit nibh. Etiam mattis massa in sem sollicitudin, non blandit dolor pharetra. Vivamus pretium nunc ut lacus interdum, ut feugiat lectus blandit. Vestibulum sit amet scelerisque lectus. Nam ut lorem mattis urna semper rutrum.
-
-Maecenas imperdiet libero et metus porta maximus. Duis lobortis porttitor sem, ut dictum urna consequat vitae. Sed consectetur est at arcu fringilla scelerisque. Nulla finibus libero eu nibh vulputate euismod. Praesent volutpat nisi eget elit dignissim, ac imperdiet nisi mollis. Integer a venenatis neque. Fusce leo leo, auctor sit amet auctor in, elementum quis magna.
-
-Donec efficitur ullamcorper ex eget pretium. Suspendisse pharetra sagittis neque, eget laoreet sem maximus et. Etiam sit amet mi ut purus ornare molestie a nec diam. Sed eleifend dui at orci sollicitudin bibendum. Mauris non leo eu est consequat porttitor consectetur vel massa. Nullam pretium molestie leo in hendrerit. Etiam dapibus ante tellus, quis hendrerit turpis feugiat vitae. Maecenas id lorem quis nibh tincidunt accumsan sed sed nisi. Duis non faucibus odio. Fusce porta enim vitae ex ultrices, non euismod nibh posuere.
-
-Suspendisse luctus orci blandit, tempor ipsum in, molestie erat. Fusce commodo sed sapien quis interdum. Etiam sollicitudin ipsum a ipsum tempus, a vestibulum ligula hendrerit. Integer eget nisl a arcu hendrerit sollicitudin. Fusce a purus ornare, sollicitudin ante in, gravida elit. Vestibulum ut tortor volutpat, sodales enim eget, aliquam risus. Pellentesque efficitur nec sem id molestie. Mauris molestie, risus sit amet dignissim dictum, turpis ante vehicula tellus, in eleifend risus metus in mi. Aenean interdum ac metus ac porttitor. Vivamus nec blandit arcu. Maecenas fringilla varius metus, sed viverra diam facilisis a.
-
-Curabitur placerat cursus sem, in laoreet elit mollis in. Nam convallis aliquam placerat. Sed quis efficitur est. Proin id massa quam. Fusce nec porttitor quam. Nunc ac massa imperdiet, pretium nibh quis, maximus nisi. Interdum et malesuada fames ac ante ipsum primis in faucibus. Donec pretium purus id viverra fringilla. Cras congue facilisis orci et ullamcorper. In ac turpis arcu. Praesent convallis in ligula vitae suscipit.
-
-Etiam et egestas ipsum, ac lacinia erat. Nunc in metus sit amet lectus ultricies viverra in sed elit. Ut euismod urna eget nisl faucibus, accumsan vestibulum dolor suscipit. Aenean a volutpat ipsum. Nulla pharetra enim eu lorem vestibulum malesuada. Nulla facilisi. In congue at odio vel imperdiet. Fusce in elit in nibh dapibus rutrum. Donec consequat mauris a sem viverra egestas. Suspendisse sollicitudin dapibus finibus. Nullam tempus et lacus sed feugiat. Suspendisse aliquet, sem a fringilla elementum, ante lorem elementum odio, quis sollicitudin magna nibh sed libero. Maecenas convallis congue neque, ut molestie nibh porttitor ac. Vestibulum quis justo sed ipsum tempus viverra. Quisque mauris erat, varius a ipsum eu, porta molestie odio. Morbi mauris ante, sagittis eget nibh vel, volutpat faucibus nunc.
-
-Donec id neque feugiat, tristique neque et, luctus nibh. Duis vel lacus eu nisl dignissim sagittis sed sed lacus. Praesent luctus eleifend aliquet. Sed tempus facilisis lorem, sit amet tristique metus suscipit ac. Vestibulum id sapien ac erat luctus fermentum venenatis sit amet erat. Maecenas posuere finibus mi. Phasellus facilisis efficitur turpis sed auctor. Nullam lobortis ornare velit ac scelerisque. Vestibulum facilisis, odio ac finibus viverra, leo leo sodales arcu, sed ornare ex ligula vel lacus. Nullam odio orci, pulvinar eu urna in, tristique ornare augue.
-
-Vivamus scelerisque egestas justo, at dignissim erat elementum id. Etiam vel suscipit erat. Nulla accumsan ex sem, id pharetra eros tincidunt sodales. Nullam enim augue, interdum ut est ac, faucibus semper justo. Aliquam ut iaculis magna. Sed magna turpis, pretium nec lobortis vel, facilisis vitae mauris. Donec tincidunt eros in mauris maximus porta id vehicula mi. Integer ut orci lobortis turpis vehicula viverra. Vestibulum at blandit nunc, ac pretium quam. Morbi ac metus placerat, congue lorem nec, pharetra neque.
-
-Sed vestibulum nibh ex, fringilla lobortis libero sodales sed. Aenean vehicula nibh tellus, egestas eleifend diam sollicitudin non. Fusce ut sollicitudin leo. Nam tempor dictum erat sit amet vestibulum. Pellentesque ornare mattis ex, nec malesuada elit sollicitudin vitae. Nulla nec semper enim, venenatis ornare orci. Aliquam urna purus, ornare eu ipsum vitae, consectetur faucibus elit. Nulla vestibulum semper ligula, id rhoncus tortor accumsan nec. Vestibulum non ante sed urna efficitur imperdiet vitae quis felis. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque rutrum quam sit amet nisl facilisis, quis maximus ante bibendum.
-
-Integer vel tortor nec est sodales posuere ut ac ipsum. Curabitur id odio nisl. Sed id augue iaculis, viverra risus nec, bibendum nunc. Cras ex risus, semper ac lorem nec, mattis dictum purus. Aenean semper et lacus at condimentum. Fusce nisl dolor, facilisis nec velit at, tempus pharetra mauris. Nam ac magna urna. Nulla convallis libero sed ex eleifend, ac molestie magna rhoncus.
-
-Donec blandit aliquam metus molestie suscipit. Cras et malesuada urna, non facilisis turpis. Donec non orci at leo aliquet porttitor vel non turpis. Nam consequat libero quam, non egestas ipsum eleifend quis. Mauris laoreet tellus enim, ac porta sapien condimentum quis. Nunc non sagittis orci. Aenean leo nibh, feugiat in turpis eget, hendrerit faucibus ligula. Morbi et massa nulla. Curabitur ac tempus nibh. Quisque commodo imperdiet viverra. Quisque sit amet condimentum mauris.
-
-Aliquam vel velit sed turpis consectetur eleifend quis et quam. Integer sed magna vel nisl consectetur lacinia vitae et ante. Duis consequat nulla ac leo auctor, ac euismod ipsum semper. Aliquam libero neque, imperdiet et nisi fringilla, vehicula elementum leo. Phasellus facilisis felis nec sagittis sodales. Donec ac consectetur odio. Aliquam eu aliquam lacus. Aliquam dictum eleifend risus, hendrerit eleifend nibh feugiat at. Aenean id tristique justo. Maecenas vel nibh quis massa aliquam convallis in eget mauris.
-
-Vestibulum nec fringilla neque, sit amet pellentesque dolor. Aenean a dolor enim. Morbi urna orci, mollis in viverra vel, volutpat vitae magna. Aenean sodales nec nisi ultrices condimentum. Quisque in turpis lobortis purus elementum maximus lacinia et nibh. Donec sed tortor eu nibh bibendum convallis in quis massa. Integer efficitur ultricies odio vel commodo.
-
-Quisque fermentum odio sit amet nunc tempus, vel porta nunc lobortis. Nam pellentesque elit non leo interdum, blandit eleifend purus suscipit. Nullam porta est non enim vulputate, ut molestie tortor ullamcorper. Donec fermentum, lectus suscipit commodo aliquet, tellus lacus rutrum ante, quis condimentum risus nisi id risus. Ut dapibus hendrerit odio non aliquet. Integer neque odio, dictum ac efficitur sit amet, facilisis a lacus. Nulla placerat erat et tortor placerat, vel posuere felis dignissim. Morbi non scelerisque ipsum. Aliquam hendrerit vestibulum metus vel pellentesque. Nunc fringilla turpis sodales nisi vestibulum faucibus. Quisque vehicula est arcu, tempus eleifend lorem scelerisque vitae.
-
-Nullam vehicula tortor vel purus hendrerit convallis. Cras sagittis metus ex, sit amet sollicitudin lectus vulputate quis. Integer sem odio, lobortis et pretium non, pharetra ut lorem. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Pellentesque aliquam aliquet lorem, faucibus venenatis diam viverra in. Nullam pulvinar, nisi vel elementum venenatis, lacus risus convallis neque, ac eleifend lorem enim ac turpis. Pellentesque tellus quam, dictum eu nisl non, cursus pellentesque justo.
-
-Cras pharetra lorem sed magna vulputate, eget iaculis elit molestie. Morbi a est finibus, condimentum nunc at, feugiat magna. Curabitur turpis turpis, placerat sed risus vitae, porta volutpat elit. Phasellus id neque diam. Maecenas eu metus a urna iaculis egestas eget at elit. Nunc vehicula molestie dapibus. In auctor sapien eget mi tempus, eu tempor massa egestas. Pellentesque metus sem, pharetra non urna ac, convallis hendrerit massa. Mauris nunc velit, maximus sit amet est sit amet, gravida ultrices elit. Vivamus ut luctus nisl. Nam et ultrices ipsum. Maecenas eget blandit mi. Curabitur eu lorem nec est vehicula sodales.
-
-Vestibulum hendrerit sed est vitae egestas. Nam molestie, augue non consequat efficitur, elit purus commodo orci, et pharetra ante risus eget augue. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Maecenas a nulla enim. Ut accumsan sodales ultrices. Quisque gravida, leo rhoncus placerat egestas, eros felis posuere diam, ut eleifend orci nisl vitae lorem. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Etiam sit amet urna venenatis, pulvinar nisi eget, tristique nisi. Nam nec purus hendrerit, congue augue et, facilisis diam. Donec aliquet eleifend mauris. Vivamus eu libero rhoncus, scelerisque metus at, hendrerit quam. Cras vulputate, magna eget pretium accumsan, tortor nunc molestie quam, at vulputate turpis velit eget arcu. Etiam tristique sollicitudin est, in condimentum diam faucibus vitae.
-
-Curabitur id lorem elementum diam sollicitudin gravida a sit amet ipsum. Pellentesque tortor ligula, auctor at ultricies non, pulvinar et risus. Ut vitae cursus metus. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Sed quis tortor feugiat, fermentum nunc at, sodales massa. Donec efficitur euismod diam non sodales. In eu augue quis enim elementum auctor. In hac habitasse platea dictumst. Cras in libero nec urna tempor venenatis vitae a diam. Nam vulputate nisl nulla, ut porttitor elit euismod non. Praesent eget tempus lacus, vel ullamcorper nulla. Quisque ut risus nibh. Nam rhoncus commodo consectetur. Sed ultrices sapien id lectus imperdiet, sed tincidunt est dapibus.
-
-Integer posuere mattis ipsum congue ullamcorper. Nunc ac vulputate magna. Ut bibendum scelerisque lectus. Nullam laoreet porta nunc, in viverra dolor blandit eu. Ut semper id urna quis bibendum. Vivamus sed felis nec sapien faucibus volutpat sed et nisi. Morbi faucibus venenatis imperdiet. Mauris semper ex ac blandit scelerisque. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas.
-
-Suspendisse vitae lectus diam. Nulla vel lectus non magna congue pharetra eget nec augue. Morbi elementum, nisl ut vestibulum varius, quam sapien convallis magna, tempus maximus nunc est vel purus. In molestie ligula sed placerat sagittis. In rutrum, felis volutpat pulvinar pharetra, arcu odio egestas augue, ut dapibus leo libero nec urna. Curabitur tortor sapien, aliquam id suscipit et, feugiat a leo. Sed mollis imperdiet tellus, ac placerat felis tristique sed. Fusce pulvinar est felis, sed rutrum neque sollicitudin sit amet. Donec tincidunt elit vel felis sagittis, sit amet vestibulum enim pellentesque. Nam accumsan rhoncus tellus vitae auctor.
-
-Praesent mattis risus eget dui finibus lobortis. Suspendisse auctor commodo viverra. Quisque a ante ante. Proin magna mi, efficitur vitae arcu vel, vehicula viverra lacus. Nulla rhoncus aliquet tortor eget iaculis. Vestibulum ac mollis risus. Curabitur non rhoncus neque. Donec non ipsum quis lectus fermentum convallis ac quis risus.
-
-Pellentesque aliquam diam diam, in tempus nisi rhoncus sed. Praesent ultricies nisl justo, sit amet suscipit lectus pharetra quis. Praesent non diam in dolor vulputate molestie ut vel nulla. Cras vel congue neque, in ultricies metus. Aliquam ultricies quam eget placerat accumsan. Aenean sodales cursus semper. Donec justo ex, euismod et mollis at, congue a arcu.
-
-In at sapien pulvinar, scelerisque felis sit amet, hendrerit diam. Aliquam pellentesque est vel augue dignissim, quis ornare sapien tincidunt. Nullam porta tincidunt tempus. Morbi eget arcu sed mauris tincidunt malesuada. Vivamus eleifend tortor in diam vulputate, non convallis nisi sodales. Vestibulum id arcu quis nisl maximus semper. Nunc quis dui vitae lectus dapibus luctus. Mauris mattis convallis mi, ut fringilla velit pulvinar non.
-
-Nam auctor ligula id dignissim pretium. Aliquam id ultricies massa. Suspendisse ullamcorper nec enim non egestas. Sed tristique, est eu cursus elementum, mauris nisi consectetur nulla, dapibus ultricies tortor mi ut augue. Sed vitae velit luctus, viverra velit a, malesuada eros. Mauris efficitur tortor quam, sed sodales velit suscipit varius. Integer varius nisi sit amet pharetra consequat. Fusce a fringilla felis, vel porta risus. Maecenas nibh magna, euismod quis tellus nec, faucibus mattis erat. Nulla facilisi. Cras maximus tempor dolor, a tristique diam consectetur in. Nam semper sapien tincidunt justo ornare vehicula. Suspendisse sit amet egestas lacus, ac bibendum urna.
-
-Integer sed est id tortor molestie placerat. Pellentesque vehicula risus eget massa lacinia hendrerit. Sed ut elit quis diam posuere bibendum in et ligula. Donec lobortis lacus eget aliquet maximus. Nullam risus massa, imperdiet eu urna ut, luctus fringilla tortor. Ut imperdiet nibh metus. Sed vitae purus nisl.
-
-Nunc sed magna arcu. Proin ornare lectus at semper hendrerit. Donec mi nunc, mattis in nibh a, facilisis ornare arcu. Curabitur in pretium turpis. Donec vulputate turpis sem, quis consectetur felis euismod a. Nullam sapien libero, dictum a odio a, pretium accumsan mauris. Nunc et velit varius, gravida metus non, mollis dui. Praesent nec dictum lorem, id bibendum nisi. In hac habitasse platea dictumst. Curabitur in imperdiet eros. Quisque vitae turpis lorem. In hac habitasse platea dictumst. Aliquam lobortis felis sit amet metus maximus, sit amet vulputate lorem ornare. In non ultrices eros.
-
-Praesent tellus nisl, feugiat ut rhoncus at, euismod ac ipsum. Donec vitae felis consectetur dolor ultricies scelerisque et at mauris. Donec justo lorem, euismod non velit ac, malesuada tempus sem. Pellentesque nunc sem, pharetra sed fermentum non, dignissim at nunc. Sed placerat dignissim dolor vitae malesuada. Maecenas in orci in arcu dictum facilisis eget et dui. Sed sed elit sed augue cursus rhoncus gravida sit amet mauris. In vel tempor lectus. Vestibulum congue, quam et feugiat placerat, tortor urna elementum magna, et laoreet neque orci id felis. Aliquam scelerisque nisi eget nisl dignissim, id luctus dolor tempus. Etiam ornare, magna vel dictum faucibus, ante lacus interdum sem, non malesuada urna felis quis dolor. Donec faucibus sagittis elementum. Fusce id risus eu nulla ornare tincidunt iaculis id erat.
-
-Suspendisse potenti. Nunc tristique nulla ac elementum ornare. Quisque finibus vitae erat at molestie. Maecenas consectetur mollis odio eu luctus. Phasellus id velit et nunc euismod varius vel vel dolor. Duis tempus nisi eu risus laoreet porta. Sed tempor eget neque eget pharetra. Duis non massa ac sem vulputate congue. Aliquam sodales sapien nisi, ut egestas orci ornare volutpat. Ut dui libero, viverra vel turpis vitae, molestie auctor justo. Pellentesque lacinia arcu vitae nunc auctor, nec elementum lorem malesuada. Interdum et malesuada fames ac ante ipsum primis in faucibus. Interdum et malesuada fames ac ante ipsum primis in faucibus. Integer at aliquet diam. Duis sit amet orci nec urna convallis ultrices at nec nunc.
-
-Quisque rutrum eros vel ipsum tincidunt, quis pulvinar mi tincidunt. Quisque eget condimentum diam. Fusce porttitor maximus dolor et suscipit. In turpis tellus, semper hendrerit elit at, elementum fringilla nisl. Curabitur a maximus nunc. Ut dictum dignissim lectus, et convallis eros volutpat non. Sed tempor orci risus, nec fringilla nisl dictum quis. Nunc id sagittis ipsum.
-
-Fusce sollicitudin suscipit risus, tincidunt fermentum odio cursus eget. Proin tempus, felis et dignissim gravida, quam libero condimentum ligula, eget commodo libero sapien eget magna. Quisque feugiat purus mi, in facilisis augue euismod non. In euismod pharetra enim, non tristique purus dictum ac. Maecenas sed diam tincidunt, mollis neque a, imperdiet est. Sed eu orci non nulla mollis consequat et quis metus. Fusce odio metus, tincidunt ac velit sit amet, tempor posuere tortor. Vestibulum ornare, quam non vulputate feugiat, diam nibh finibus augue, at pharetra lectus nibh quis metus. Nam dignissim quis tellus eget aliquet. Proin iaculis sit amet ex eu vehicula. Etiam vehicula sollicitudin laoreet. Praesent venenatis luctus est. Suspendisse potenti. Donec luctus molestie mollis. Vestibulum quis tortor ut mauris porta gravida sed sit amet felis. Aliquam in ex condimentum, volutpat eros scelerisque, accumsan orci.
-
-Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Maecenas vitae viverra sapien. Suspendisse vel accumsan libero, ac rutrum purus. Aliquam in risus sed metus sollicitudin convallis eget in purus. Phasellus sagittis vestibulum magna, quis scelerisque augue malesuada vel. Quisque felis leo, vulputate laoreet enim lacinia, gravida viverra urna. Aliquam faucibus vestibulum maximus. Praesent scelerisque velit quis pellentesque varius. Ut consectetur ut risus a bibendum. In mollis sapien vitae ipsum volutpat, sit amet mattis nibh dictum. Curabitur eros ipsum, tincidunt et mauris id, maximus mattis sem. Mauris quis elit laoreet, porttitor nulla sit amet, feugiat tortor. Cras nec enim pulvinar, tincidunt lorem molestie, ornare arcu. Cras imperdiet quis ante vitae hendrerit. Sed tincidunt dignissim viverra.
-
-Aenean varius turpis dui, id efficitur lorem placerat sit amet. In hac habitasse platea dictumst. Integer quis pulvinar massa. Proin efficitur, ipsum eget vulputate lobortis, nibh ipsum faucibus magna, non luctus lorem nulla sed magna. Vestibulum scelerisque sed tortor eu aliquet. Curabitur et leo ac tellus pretium egestas. Cras blandit neque dui, eget dictum leo porttitor sed. Sed ultricies commodo tortor, a molestie ante scelerisque vitae. Duis faucibus quis magna nec lacinia. Morbi congue justo id dui ultricies condimentum. Pellentesque maximus faucibus gravida. Mauris vestibulum non libero sit amet fringilla. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras id lorem condimentum, sodales dui id, blandit dolor. Sed elit mauris, aliquet nec enim vitae, sollicitudin pretium dui. Cras lacus sapien, maximus in libero et, elementum fermentum nunc.
-
-Vestibulum gravida cursus nisi sed congue. Nam velit lorem, porttitor id pharetra finibus, malesuada eget dui. Vestibulum at est ultrices, venenatis nulla sed, suscipit risus. Maecenas posuere pretium odio nec accumsan. Aliquam dui dui, laoreet sed felis non, dignissim hendrerit ante. Etiam id commodo ante. Aenean bibendum enim aliquet fringilla dictum. Morbi eu feugiat risus.
-
-Praesent gravida a ante non placerat. Mauris ultricies ullamcorper justo id viverra. Aenean semper metus eu nisl euismod suscipit. Proin erat quam, viverra ut metus eget, imperdiet accumsan nunc. Curabitur non enim a odio maximus pulvinar ac et elit. In auctor ex a malesuada malesuada. Nullam dapibus quam neque, a lacinia magna tempor eget. Nam pellentesque, nisl eget gravida porta, felis magna lacinia ipsum, eu lacinia felis dui non libero. Phasellus ut convallis urna. Curabitur convallis sem vel tortor lobortis molestie. Nunc vel fringilla mi. Donec eget libero ultricies, euismod nibh non, gravida mauris. Praesent malesuada, lectus at sollicitudin interdum, mi lacus aliquam metus, non gravida tortor velit ac justo. Suspendisse auctor tellus sapien, at eleifend erat mollis et.
-
-Sed a dictum quam. Sed accumsan libero vel feugiat vulputate. Cras mattis massa nec velit rhoncus luctus. Sed ornare, augue vel ornare lobortis, purus nulla interdum ipsum, a semper massa enim quis nunc. Nunc tempor efficitur odio, vel consequat dui fringilla ac. Quisque at quam sed lacus rhoncus sollicitudin. Nunc dolor libero, dictum a ornare id, euismod ac lectus. Quisque a hendrerit lectus. Nam ut diam eu neque viverra porttitor. Proin vitae accumsan eros, ut iaculis lorem. Nulla libero odio, mollis sed venenatis et, imperdiet ut ligula.
-
-Aliquam dignissim erat erat, vel imperdiet arcu sagittis id. In in dolor orci. Aliquam congue fermentum dui tristique viverra. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Curabitur a turpis in dolor consequat pulvinar. Pellentesque sed posuere nisl. Etiam pellentesque euismod sem. Quisque vitae nibh urna. Phasellus elementum arcu urna, ac scelerisque leo iaculis non. Etiam laoreet, nunc a consectetur rhoncus, nunc tortor feugiat nibh, vitae volutpat metus mauris in est. Pellentesque at neque eu arcu faucibus auctor nec vitae urna. Suspendisse semper tristique nisl id interdum.
-
-Integer dui libero, auctor id elementum a, convallis eu est. Praesent auctor sodales faucibus. Aenean faucibus euismod orci, vestibulum pharetra magna consectetur vel. Praesent a enim vel nisi aliquam tristique ut id metus. Donec at purus dui. Sed a aliquam velit, non viverra ex. Ut molestie interdum urna vel facilisis. Nunc iaculis aliquet turpis eu luctus. Vestibulum mollis diam vel ante finibus, a efficitur est tempus. Nulla auctor cursus sagittis. Nullam id odio vitae orci tristique eleifend.
-
-Ut iaculis turpis at sollicitudin accumsan. Cras eleifend nisl sed porta euismod. Nullam non nisi turpis. Cras feugiat justo nec augue pretium fermentum. Nunc malesuada at nulla a interdum. Proin ullamcorper commodo ligula ac rutrum. Praesent eros augue, venenatis vitae enim sit amet, ultricies eleifend risus. Nunc bibendum, leo ac consequat porttitor, diam ante posuere turpis, ut mattis odio justo consectetur justo. Phasellus ex dolor, aliquam et malesuada vitae, porttitor sed tellus.
-
-Praesent vitae lorem efficitur, consequat enim ut, laoreet nisi. Aliquam volutpat, nisl vel lobortis dapibus, risus justo lacinia justo, viverra lacinia justo lorem egestas nibh. Suspendisse pellentesque justo sed interdum sagittis. Maecenas vel ultricies magna. Duis feugiat vel arcu ac placerat. In tincidunt a orci at feugiat. Maecenas gravida tincidunt nibh eu convallis. Quisque pulvinar rutrum cursus.
-
-Proin nec maximus tortor. Morbi pellentesque magna vitae risus scelerisque elementum. Nulla fringilla neque at arcu malesuada rutrum. Fusce nisi magna, elementum fringilla elit ut, lacinia varius purus. In accumsan justo ex, vitae suscipit velit finibus cursus. Morbi sed suscipit orci. Fusce nulla erat, fermentum vel aliquam vitae, eleifend et elit. Maecenas id elit a ligula vestibulum blandit ut at eros. Etiam ac bibendum massa, sagittis viverra dolor. Maecenas sed sapien nec elit fringilla molestie a vel purus. In in semper odio, quis consectetur dolor. In sed metus a nisi tincidunt posuere nec eget erat.
-
-Maecenas non auctor sem. Nullam in turpis sagittis, fermentum neque finibus, fermentum justo. Sed id nisl mattis, commodo felis in, dapibus turpis. Nullam in elit in nunc aliquam laoreet vel vitae magna. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec tincidunt tempus imperdiet. Nulla est est, mollis imperdiet varius nec, porta in nulla. Vestibulum volutpat euismod nisi vel laoreet.
-
-Cras congue egestas sodales. Nam commodo malesuada est nec volutpat. Ut gravida, turpis ac congue molestie, sapien augue molestie nulla, quis lacinia sapien dui eu nunc. Aliquam eleifend, leo et finibus pharetra, ante sapien congue purus, quis euismod urna nulla et metus. Donec vulputate hendrerit tortor quis mollis. Vestibulum et condimentum purus, vel aliquam lacus. Ut id congue sapien. Pellentesque ante lectus, hendrerit sit amet luctus quis, feugiat dignissim leo. Aenean aliquam imperdiet cursus. Praesent vulputate turpis ullamcorper felis tincidunt tincidunt. Duis quis augue vitae nibh finibus sagittis. Sed sollicitudin scelerisque tellus, ut interdum diam sollicitudin bibendum. Vestibulum iaculis fermentum sem sit amet tempus. Suspendisse lobortis eleifend fermentum.
-
-Etiam consectetur est sit amet nisl aliquet, eget fermentum tellus rhoncus. Quisque vulputate sit amet mauris eget lacinia. Fusce ac eros tellus. Suspendisse et tellus felis. Praesent ultricies nunc lorem, sed sodales orci viverra eu. Vestibulum maximus nibh et turpis efficitur, in tempus ipsum efficitur. Vivamus finibus lorem nec malesuada egestas. Praesent in nibh sagittis, volutpat risus et, commodo est. Suspendisse facilisis eu augue nec tincidunt. Fusce quis nisl tempus, tincidunt lacus nec, dapibus purus.
-
-Vivamus et ante eu ante sodales elementum sed id urna. In tincidunt vel tortor sed feugiat. Praesent iaculis diam eget pellentesque ornare. Praesent aliquet convallis odio sit amet suscipit. Morbi et nisi nulla. Nunc vestibulum risus a faucibus efficitur. Pellentesque commodo odio eu leo vestibulum, id iaculis risus sagittis. Cras a ipsum posuere, rhoncus eros in, euismod nulla. Nam semper, mi id tempor sodales, diam sem blandit odio, eget posuere tellus nisi nec tortor. Etiam nec tortor congue, sodales ante ac, malesuada elit. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Fusce fringilla eros sit amet orci vestibulum aliquam. Suspendisse fermentum malesuada est, sit amet condimentum ante volutpat nec. Integer sit amet magna molestie, feugiat odio a, condimentum lectus.
-
-Nullam odio ligula, mollis eu massa ac, maximus interdum velit. Vestibulum vulputate a justo ac efficitur. Quisque ex est, pretium id velit nec, malesuada posuere arcu. Sed congue lacus nec velit vehicula, a egestas erat mattis. Nunc eget leo a metus rhoncus mollis. Maecenas at elit nec est condimentum suscipit. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Duis nisi mauris, consequat varius mollis at, porta ac dolor. Mauris vitae euismod lorem, ut dapibus turpis. Vivamus sit amet iaculis turpis. Nulla molestie feugiat urna in pharetra.
-
-Nam ac elit vulputate magna venenatis pharetra ac eu elit. Donec sed eros id lacus molestie rutrum. Sed iaculis mauris nunc, non fringilla ante semper eu. Maecenas in auctor eros. Vestibulum eu enim lorem. Etiam tristique dui id justo blandit dignissim. Aenean quis faucibus eros. Quisque vel dolor lectus. Etiam lacus enim, laoreet varius dolor ut, sollicitudin imperdiet lacus.
-
-Quisque vel nibh sollicitudin urna pellentesque euismod sed sed lorem. Suspendisse in condimentum ipsum, eu convallis ipsum. Nunc faucibus condimentum ante efficitur imperdiet. Donec tempor egestas efficitur. Morbi et aliquam nisl, quis iaculis elit. Fusce eu elit et sapien auctor ullamcorper. Curabitur sem orci, pharetra vitae facilisis non, scelerisque et mi. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Ut molestie eu velit id ultricies. Maecenas vehicula id tortor sit amet faucibus. Duis porta enim nec vestibulum posuere. Aenean blandit fringilla lacus accumsan pellentesque. Integer ut ante elementum, imperdiet metus sit amet, consequat orci.
-
-Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce eget libero non arcu luctus pulvinar. Vestibulum condimentum tellus nec enim bibendum aliquam. Nulla non placerat massa. Donec vestibulum nibh at rutrum mollis. Aliquam erat volutpat. Vivamus metus est, rhoncus a efficitur id, blandit id dolor.
-
-Nunc rutrum lacus ut pharetra feugiat. Sed volutpat semper metus sit amet placerat. Phasellus efficitur porta venenatis. Quisque imperdiet metus nunc, nec porttitor turpis iaculis ut. Sed at orci eget eros lacinia volutpat. Etiam sagittis euismod diam quis ullamcorper. Nulla facilisi. Praesent faucibus neque vel tortor pharetra, ac tincidunt nunc rutrum. Phasellus aliquam nulla in augue rhoncus, a lacinia tellus pretium.
-
-Praesent in mauris lectus. Aliquam molestie nulla vitae nulla consectetur convallis. Sed eu molestie velit, vitae venenatis elit. Quisque eget ultricies mauris, at euismod risus. Sed gravida velit ut risus tempor suscipit. Maecenas metus nisi, pellentesque in ornare et, fermentum et lectus. Interdum et malesuada fames ac ante ipsum primis in faucibus.
-
-Quisque in mi congue, molestie massa a, fermentum tellus. Integer vitae tortor iaculis, tincidunt magna et, egestas ligula. Sed feugiat metus id erat faucibus, ac bibendum enim sollicitudin. Cras hendrerit massa sapien, et consequat tellus accumsan lacinia. Nam pharetra, ipsum ut vestibulum fringilla, sapien eros finibus leo, eget suscipit nibh arcu aliquam quam. Quisque sollicitudin id est eu rutrum. Nunc vitae tincidunt nisi, euismod viverra enim. Maecenas mattis sapien at felis hendrerit dignissim.
-
-Quisque eu urna nulla. Integer at eros fermentum est mattis rutrum at nec massa. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Etiam ut hendrerit nunc. Vestibulum est velit, rhoncus quis nisi sed, lobortis aliquet metus. Nunc faucibus egestas magna sit amet ornare. Maecenas eu justo mi. Proin tincidunt sem vel metus efficitur, sit amet malesuada augue cursus.
-
-Vestibulum viverra augue ut lorem accumsan, nec lacinia ligula accumsan. Maecenas viverra mauris dolor, vitae molestie mi accumsan nec. Ut nec sagittis nisl, fringilla viverra magna. Cras condimentum ultrices sollicitudin. Morbi tempor, massa ut iaculis posuere, arcu erat luctus massa, vitae pulvinar nulla ex nec nulla. Mauris vitae scelerisque ipsum. Nullam tincidunt consequat augue, quis aliquam nulla. Integer non arcu erat. Etiam scelerisque sodales vestibulum. Sed luctus arcu eu leo consectetur, at porta arcu elementum.
-
-Morbi in eleifend neque. Quisque a blandit libero, dignissim porta tortor. Sed nunc metus, aliquam a elit et, sagittis dictum arcu. Vestibulum lacinia nisi quis luctus ultricies. Fusce erat eros, euismod sit amet luctus vel, tempor a nunc. Aliquam nec nulla id est molestie tincidunt ac sit amet arcu. Donec molestie laoreet sapien, sit amet vulputate turpis facilisis at. Nullam eget nisi vel nibh elementum euismod non tempus leo. Nulla suscipit consectetur ante, nec fringilla lectus porta ac. Proin nec odio in lacus suscipit lacinia et sagittis ante. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Sed rhoncus lacinia porttitor. Pellentesque sapien ipsum, sagittis posuere arcu ut, laoreet gravida elit. Aenean eu tortor sit amet massa tincidunt facilisis. Aenean congue eget orci vitae vestibulum.
-
-Nunc tempus augue rhoncus condimentum vehicula. Sed in dui sit amet arcu varius pellentesque quis cursus nisl. Proin faucibus erat id egestas suscipit. Nam accumsan in tellus nec elementum. Phasellus nunc orci, mattis nec sollicitudin ultrices, feugiat eu lectus. Morbi ullamcorper rutrum sapien non rhoncus. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Quisque orci sapien, fringilla et dictum sit amet, tristique vel arcu. Maecenas tempus porttitor mattis. Cras eget faucibus enim.
-
-Mauris ornare mattis tortor. Duis convallis a ipsum id cursus. Aenean viverra, eros pellentesque ullamcorper posuere, orci ligula luctus odio, vel rutrum ex lectus eu erat. Etiam mollis nulla orci, fringilla gravida mauris viverra eu. Sed et orci non purus ultricies elementum. Cras at lectus hendrerit, fringilla lacus nec, feugiat sem. Morbi in metus felis. Etiam tempor bibendum ex eu venenatis.
-
-Cras ac nibh condimentum, lacinia sem ut, pretium felis. Sed congue, mi at accumsan semper, felis lorem vestibulum nisl, ac commodo lorem eros at mi. Curabitur condimentum nunc justo. Nulla efficitur venenatis nibh sed finibus. Integer iaculis volutpat mi dictum bibendum. Nullam tempus id ante euismod placerat. In placerat auctor lacus ac molestie. Aenean ultricies egestas imperdiet.
-
-Ut interdum cursus accumsan. Aliquam a mi ligula. Nunc blandit, metus in pellentesque aliquet, velit libero aliquam quam, nec egestas est turpis at ante. Quisque et magna eget massa gravida suscipit. Ut in lectus a massa eleifend sagittis rhoncus faucibus lectus. Maecenas sit amet elit vel tellus varius feugiat ac ut diam. Ut iaculis non ante in molestie. Integer pulvinar vulputate velit, ornare dignissim sapien laoreet ut. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas.
-
-Aliquam finibus tristique laoreet. Pellentesque et diam tincidunt orci hendrerit euismod. Phasellus viverra orci vitae interdum imperdiet. Phasellus gravida auctor nisi, vitae rhoncus est dignissim eget. Phasellus eu facilisis eros, vitae iaculis quam. In condimentum velit non iaculis porta. Proin ipsum ex, egestas nec molestie sit amet, vehicula sed ante. Proin eget eros at nibh sollicitudin luctus a id magna. Nam eget turpis finibus, tempor libero nec, auctor velit. Nunc neque magna, dictum vel semper nec, facilisis eu lectus. Maecenas maximus tortor eget ex dictum, sit amet lacinia quam tincidunt. Nulla ultrices, nunc ac porta feugiat, diam dolor aliquet sapien, sit amet dignissim purus ante in ipsum. Maecenas eget fringilla urna. Etiam posuere porttitor interdum. Vestibulum quam magna, finibus et urna auctor, pulvinar viverra mauris. Fusce sollicitudin ante erat.
-
-Maecenas pretium facilisis magna, at porttitor turpis egestas non. Morbi in suscipit felis. Duis eget vehicula velit, posuere sodales lorem. Curabitur elementum a lectus non ornare. Donec vel eros scelerisque ipsum iaculis accumsan. Phasellus tincidunt tincidunt lobortis. Vestibulum maximus risus tellus, eu faucibus urna tincidunt quis. Fusce dignissim lectus vel enim ultricies, in efficitur purus semper. Etiam sit amet velit pulvinar, hendrerit erat et, maximus eros.
-
-Maecenas iaculis convallis consectetur. Duis ante nulla, commodo sit amet diam sed, tempus mattis risus. Maecenas volutpat leo leo, in mollis eros mollis quis. Aenean sagittis, neque id mattis varius, tortor leo cursus ligula, a ultricies justo turpis ut libero. Ut sit amet nibh et erat pellentesque rhoncus. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Integer rhoncus ligula nec iaculis faucibus. Curabitur tincidunt eu diam eget ultrices.
-
-Vestibulum quis nisl nec lacus commodo efficitur eu eleifend turpis. Etiam pretium id nisl a vehicula. Praesent elementum malesuada nisl. In condimentum interdum faucibus. In sed mauris vestibulum dui ultricies congue. Ut posuere mattis ante, in blandit mauris suscipit quis. Pellentesque ligula turpis, tincidunt a laoreet vel, consectetur in est. Nulla gravida ligula vel lectus faucibus accumsan. Praesent rhoncus eros arcu, id ultrices ipsum maximus ac. Mauris tincidunt cursus erat nec vulputate. Nulla tristique imperdiet eros vitae lobortis. Nullam a urna et sem condimentum blandit sed ut nulla.
-
-Maecenas auctor sodales facilisis. Pellentesque facilisis augue a odio varius suscipit. Etiam malesuada justo vel leo dignissim tincidunt. Sed magna metus, sagittis at diam gravida, dictum iaculis sem. Aliquam erat volutpat. Maecenas euismod egestas tortor non sollicitudin. Nulla quis odio tincidunt, auctor est sed, pretium turpis. Quisque aliquet semper magna, sit amet gravida enim luctus at.
-
-Nulla orci risus, ultrices a nunc et, dictum tincidunt lectus. Aliquam erat volutpat. Mauris at justo feugiat, efficitur lectus id, facilisis turpis. Sed ornare sodales fermentum. Suspendisse interdum tellus ac auctor sagittis. In auctor convallis metus non elementum. Mauris id dolor aliquam, euismod sapien id, tristique mi. Duis ac eleifend lectus. Etiam odio turpis, molestie vitae posuere vel, feugiat ac lorem. Fusce tempus ligula non hendrerit maximus. Nulla facilisi. Ut pretium turpis eget eros fringilla, vel aliquam mi pulvinar.
-
-Donec rhoncus augue ac viverra lacinia. Aliquam suscipit risus id sem varius, eget aliquet justo varius. Phasellus molestie, neque vitae semper posuere, est risus blandit ligula, id lacinia lectus orci id lectus. Cras vitae massa sit amet sapien pulvinar sollicitudin facilisis sed leo. Donec risus nulla, finibus id nulla quis, ornare sollicitudin neque. Curabitur id sapien vehicula, tempor velit sit amet, auctor augue. Nunc venenatis urna quis ante mollis bibendum.
-
-Pellentesque in varius massa. Donec non odio ultricies purus hendrerit fermentum. Aliquam quis elit vitae risus porttitor efficitur in vel sapien. Vestibulum sed urna sed lorem convallis bibendum nec non eros. Nullam molestie accumsan tincidunt. Aenean interdum sapien quis sapien dictum porttitor. Ut sit amet mollis magna, sed finibus urna. Etiam porta congue nunc eu aliquam. In congue mollis tincidunt. Nunc id metus ultricies, aliquam risus vel, sollicitudin dui. In nec felis consectetur, gravida dolor eu, consectetur lorem. Ut hendrerit, velit vitae malesuada placerat, felis metus vehicula odio, in iaculis ex tortor id metus. Donec mattis elit a est sollicitudin, in lacinia nisi gravida. Nullam ornare, tellus eget pharetra mollis, purus nisl condimentum sapien, vel ultricies enim libero ac ex. Fusce sed ligula a arcu lacinia tempor sit amet et magna. Maecenas fermentum nec diam in ornare.
-
-Cras pellentesque facilisis accumsan. Curabitur vehicula volutpat diam, vel tincidunt felis cursus sed. In malesuada leo et porta pulvinar. Integer at ultrices nunc, a tincidunt metus. Vivamus eu tellus vel lectus volutpat fringilla. Donec ut egestas est. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce non hendrerit turpis. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Etiam in ipsum quis ipsum hendrerit egestas. Donec vitae lectus malesuada, consequat enim et, lobortis velit. Vestibulum nec augue ex. Nullam ut porta lacus. Morbi pellentesque gravida purus, a interdum felis. Nulla lacus libero, euismod quis posuere in, congue pretium ipsum. Aliquam at suscipit nisi.
-
-Sed et venenatis purus, at maximus dolor. Fusce varius eget turpis ac sodales. Nullam sed mauris quis diam hendrerit dapibus consectetur eget dolor. Suspendisse maximus ac velit quis condimentum. Praesent ac mattis mauris. Morbi aliquet dignissim sem, sed mattis enim vestibulum vitae. Morbi sed dui in sapien elementum ullamcorper. Proin feugiat viverra ipsum et commodo. Nam pellentesque turpis nec condimentum aliquam.
-
-Praesent luctus elit sit amet est fermentum, nec egestas lectus scelerisque. Proin ornare mi eu turpis sodales, at vestibulum magna placerat. Suspendisse potenti. Nulla vel elit semper, blandit nunc vel, ullamcorper turpis. Morbi eu posuere sapien, ac iaculis tellus. Etiam tincidunt nunc vitae cursus faucibus. Phasellus rhoncus sollicitudin metus, id lobortis mi iaculis nec. Donec elementum venenatis purus at commodo. Aenean egestas facilisis metus, quis posuere nisi fringilla aliquam. Fusce ac porta nibh. Aliquam hendrerit lectus magna, at auctor felis viverra a. Integer elementum posuere nunc a fringilla.
-
-Nunc metus lectus, molestie nec tincidunt at, facilisis id enim. Aenean nulla quam, convallis non lectus vehicula, dignissim interdum velit. Ut vestibulum finibus mauris. Vivamus sed euismod elit, ut pulvinar dolor. Suspendisse dictum viverra pharetra. Curabitur non erat finibus orci sodales pulvinar. Sed at consectetur quam, ut commodo lacus. Suspendisse mollis convallis lorem, nec venenatis nunc lacinia a. Proin in est dui. Nunc nec lacus lectus. Aenean faucibus dui ornare magna varius fermentum. Aenean eu justo pulvinar libero rhoncus sollicitudin at et nunc. Integer sit amet mauris hendrerit, fringilla magna quis, tincidunt nunc. Fusce sit amet aliquam leo, pretium fermentum nisl. Vestibulum hendrerit tempus suscipit.
-
-Pellentesque et augue varius, aliquam justo vel, sagittis erat. Suspendisse tincidunt maximus velit, porttitor interdum ligula elementum vel. Nunc a dictum lectus, gravida tristique magna. Quisque id risus arcu. Vestibulum porta in mi sed finibus. Nam tristique in mauris nec gravida. Vivamus arcu sem, fringilla ac purus eget, vestibulum posuere arcu. Integer aliquet elit a est scelerisque pharetra vel sit amet augue. Sed quis finibus nunc, non ornare felis. Suspendisse potenti. Maecenas sollicitudin eros urna, vel bibendum mi sollicitudin facilisis. Nam elementum ligula non augue accumsan, ut laoreet tellus ultricies. Nunc in pellentesque quam. Proin eu varius lectus. Donec gravida massa non rhoncus dignissim. Sed est sapien, vestibulum ac egestas nec, posuere id metus.
-
-Phasellus quis interdum felis. Pellentesque ac elementum lacus. Proin posuere tempor ante, et consectetur nulla convallis ut. Etiam porta sem orci, eget convallis risus hendrerit in. Mauris gravida libero id tincidunt lacinia. Donec tempus ultrices ipsum, vitae finibus velit. Sed consectetur dictum velit, in consequat dolor fermentum eget. Pellentesque porttitor tellus velit, quis dignissim purus imperdiet et. Phasellus leo lectus, mollis nec ultricies ut, placerat ut quam. Integer imperdiet mauris sed magna gravida accumsan. Nulla congue turpis at urna tincidunt, at tempus urna condimentum. Praesent ac nibh lectus. Pellentesque id odio at purus tincidunt mollis nec id massa. Nulla eget venenatis erat, ornare lobortis nulla. Fusce rhoncus metus turpis, at mattis magna blandit sed. Aliquam sed mattis massa, ut bibendum nisl.
-
-Mauris commodo vulputate nulla at sodales. Vivamus sagittis viverra ex, in scelerisque dui commodo in. Maecenas eget ante euismod, tristique tortor at, placerat turpis. Fusce hendrerit, orci et hendrerit tristique, turpis tortor hendrerit elit, vel dictum eros nisl vitae enim. Nullam et lacus velit. Donec rutrum tortor risus, eu volutpat lorem placerat tempor. Etiam rhoncus lorem quis turpis gravida placerat. Nam at magna efficitur, interdum mauris vel, tristique odio. Phasellus augue nisl, fermentum luctus sapien non, rhoncus convallis dui. Aenean nibh tellus, congue ut nulla eu, luctus lacinia est. Sed vel augue tellus. Ut congue sit amet risus ut consequat. Vestibulum id magna sed augue condimentum porttitor. In nec leo ac justo condimentum dignissim. Nullam eu gravida ipsum.
-
-Proin iaculis imperdiet nisl. Vestibulum at lectus bibendum ipsum mattis viverra. Suspendisse facilisis non nulla non dignissim. Interdum et malesuada fames ac ante ipsum primis in faucibus. Fusce scelerisque turpis ante, tincidunt laoreet risus pharetra in. Nam nisi est, hendrerit in tincidunt sit amet, accumsan placerat odio. Vivamus nec egestas ligula. Nam sit amet dignissim nulla, sit amet lobortis ex.
-
-Etiam ac tellus lectus. Cras egestas urna id ornare vestibulum. Donec ut magna id velit finibus sagittis eget at nibh. Pellentesque tempus tempor justo, sit amet rutrum massa convallis eu. Ut lacus quam, sollicitudin vel consectetur vel, cursus eu velit. Sed aliquam ex a est lacinia pretium. Sed volutpat dui at iaculis accumsan. Nam feugiat libero a ante consectetur, nec maximus metus venenatis.
-
-Fusce in nunc lorem. Aliquam vel tincidunt nisl. Duis sed laoreet dui. Nam eu dapibus lacus. Nulla odio lectus, ornare sit amet leo sed, laoreet tempus massa. Curabitur venenatis ipsum vel turpis lacinia, sed euismod diam commodo. Etiam ac turpis cursus, auctor lectus eu, sodales ex. Ut eget dolor aliquet mauris maximus volutpat vitae ut lorem. Sed vulputate arcu ex, a porttitor risus porttitor vel. Duis sed accumsan purus.
-
-Pellentesque nisi est, scelerisque eu magna in, venenatis dapibus elit. Morbi porttitor, lectus dapibus dapibus sodales, mauris eros tristique metus, vitae porta tellus quam eu arcu. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Nam fringilla nibh sed fermentum vestibulum. Aliquam quis mollis elit. Etiam lobortis purus sed nunc pulvinar malesuada. Morbi varius mattis velit efficitur convallis.
-
-Pellentesque facilisis ante id metus porta, et tincidunt quam tristique. Proin non sem vel eros venenatis tempor. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Vivamus sollicitudin non risus at mollis. Cras leo orci, tempus eget felis a, efficitur tincidunt massa. In quis augue tristique, condimentum nulla eget, vulputate sem. Sed purus neque, ultricies eu turpis facilisis, dignissim bibendum eros. Vivamus congue accumsan dui. Sed congue dolor ut nisl mattis laoreet eu eu purus. Mauris vehicula, quam vel feugiat imperdiet, libero nibh commodo mi, at ullamcorper nulla enim sed leo. In eget ante sit amet metus luctus vulputate non sed dolor. In sapien odio, egestas sit amet sapien quis, congue mattis ante. Quisque tempus ligula ut eleifend facilisis. Vivamus ornare suscipit laoreet. Nulla vitae placerat massa, interdum sollicitudin augue.
-
-Suspendisse potenti. Morbi sed scelerisque diam. Suspendisse vitae tortor arcu. Nullam a ligula condimentum, sollicitudin arcu et, fringilla elit. Vivamus dignissim gravida ornare. Etiam scelerisque ligula at est porta, in dignissim sem hendrerit. In ut mollis urna. Sed blandit purus at volutpat scelerisque. Nullam vel finibus odio. In eu neque eu ante pretium posuere. Nullam vitae accumsan neque. Nam nec elit dolor. Ut sit amet urna eros. Maecenas efficitur dui id tempor porta. Pellentesque et quam felis.
-
-Proin aliquet sem nec ipsum porta, eu tempus velit vestibulum. Nulla sed ligula sed metus sollicitudin porttitor. Fusce non posuere lacus. Phasellus luctus, eros quis rhoncus ultricies, arcu tellus rutrum tellus, eu vulputate orci ante vitae lorem. Maecenas porttitor mauris purus, ut eleifend metus sollicitudin sit amet. Curabitur ultricies erat id libero egestas, ut ullamcorper eros vehicula. Vestibulum lorem nibh, aliquam ut tincidunt elementum, tempor quis sem. Donec vehicula tempor eleifend. In hac habitasse platea dictumst. Nunc ut sem elementum, aliquam dolor sit amet, eleifend enim. In elementum viverra mi, eget pulvinar lorem fermentum non. Nam ac ligula vel dolor convallis pellentesque. In sed lectus sed arcu consequat finibus vel et ante. In iaculis id tellus in congue. Donec imperdiet lorem quis erat maximus, vitae molestie ex accumsan. Donec pharetra, orci ac rutrum pretium, nunc mauris vestibulum magna, sagittis consequat risus orci ut felis.
-
-Sed id metus eget odio suscipit efficitur id eget ligula. Phasellus massa metus, varius et metus quis, porta lobortis turpis. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. In in augue semper, consequat nunc at, tristique eros. Nullam vitae consectetur neque. Duis dignissim urna metus, vitae condimentum erat eleifend ac. In pellentesque nunc sed convallis sagittis. Integer venenatis, felis a mollis tristique, diam neque laoreet orci, ac varius diam ligula pulvinar augue. Nullam dapibus libero id est sollicitudin, non efficitur dui sollicitudin. Mauris sem diam, feugiat non ante elementum, eleifend lobortis urna. Nullam pharetra tristique diam in aliquam. Donec finibus sit amet lectus non auctor.
-
-Ut nibh tortor, sagittis ut sem eget, ultricies auctor enim. Cras malesuada ligula velit, sit amet consequat mauris interdum eget. Curabitur fermentum tristique magna facilisis ultricies. Sed quis porta arcu. Ut in nunc id velit egestas consectetur. Nulla fermentum porta nisi, vitae dapibus risus consectetur faucibus. Mauris quis magna aliquam libero dictum porta. Mauris sed iaculis turpis, non auctor turpis. Sed eget lorem ex. Sed pulvinar, mi ut rhoncus dapibus, est lorem maximus orci, ac tempor justo erat vel purus. Proin euismod turpis eu ex blandit semper. Nulla suscipit molestie ex sed auctor. In facilisis nisi convallis nulla rutrum bibendum. In aliquet leo eget quam auctor, at eleifend felis commodo.
-
-Vivamus at elit scelerisque, tristique mi non, ornare nisl. Integer posuere orci diam, sit amet malesuada nisl vestibulum ut. Sed convallis urna id arcu luctus, faucibus interdum urna varius. In hac habitasse platea dictumst. Mauris laoreet mauris vel nisi ultrices facilisis. Suspendisse mattis purus eu dui lobortis bibendum. Fusce cursus risus tellus, non fermentum lectus tristique sed. Curabitur ullamcorper tincidunt tortor vel blandit. Quisque at ligula ut sapien convallis tincidunt eu vitae dolor. Etiam consectetur lacinia sollicitudin. Sed sagittis dolor vel nulla congue mollis. In ut felis gravida, luctus massa sed, venenatis ante. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Nunc facilisis lobortis dapibus.
-
-In a velit nibh. Nam mollis nunc sed faucibus eleifend. Sed maximus malesuada ultrices. Donec mattis finibus nunc, eu viverra massa egestas non. Donec arcu velit, sagittis et tempor mollis, malesuada in mi. Duis rhoncus suscipit lorem ac lobortis. Vestibulum malesuada nibh at nulla ornare, at pulvinar magna tincidunt. Ut tellus risus, commodo vitae fringilla nec, semper quis nulla. Suspendisse euismod eros vel leo commodo, ac sollicitudin velit porta. Donec non dolor blandit, tempor magna eu, suscipit risus. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Donec libero nisl, auctor in rhoncus sed, viverra a arcu. Etiam diam ex, luctus non ultrices quis, viverra ut quam. Mauris lobortis suscipit quam, malesuada pretium nibh ultrices non. Suspendisse molestie, risus sit amet venenatis semper, justo justo tempor tortor, vel iaculis ligula dui sed erat.
-
-Donec odio ligula, aliquam id mollis eget, tincidunt nec arcu. Duis aliquam elementum facilisis. Vivamus lobortis fermentum egestas. Etiam ac orci sit amet dui dignissim condimentum. Maecenas magna arcu, mollis eget nisl a, vestibulum finibus lacus. Praesent et metus risus. Morbi semper neque vel erat fermentum, commodo posuere sem porta. Proin sit amet ipsum at lectus vestibulum luctus. Nullam convallis nulla ac pretium facilisis. Nunc porttitor convallis mi nec vestibulum. Phasellus vehicula vestibulum ornare. Curabitur commodo sapien quis vulputate egestas. Suspendisse potenti. Vestibulum quis mattis nisi.
-
-Maecenas mattis ex eget placerat aliquet. Pellentesque est nibh, ultrices eu laoreet in, interdum vitae nunc. Suspendisse sit amet metus hendrerit, fringilla quam at, mollis arcu. Nullam tempus metus volutpat felis fermentum, et accumsan nisl placerat. Maecenas pharetra feugiat eros sit amet consectetur. Donec vehicula tincidunt massa eu sagittis. Integer massa nisl, luctus quis nisi et, molestie cursus turpis. Aliquam congue ipsum eget turpis vehicula, commodo eleifend neque placerat. Nam vel consequat urna. In pellentesque lobortis tempus. Pellentesque pharetra, purus in pretium convallis, turpis orci maximus tortor, eu malesuada ex elit sit amet lorem.
-
-Curabitur sit amet aliquet quam, non aliquet tellus. Pellentesque nec ipsum dolor. Aliquam blandit gravida dolor vitae porta. Integer enim purus, scelerisque id molestie sed, accumsan vel nulla. Aenean vel ultricies urna. Nam consequat ipsum tempor mi placerat, id pretium dolor cursus. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae;
-
-Sed venenatis dui mauris, pellentesque varius magna malesuada blandit. Etiam sed tempor ipsum, id tincidunt nisl. Sed a felis mi. Nulla orci metus, auctor ac malesuada lobortis, facilisis vel nisl. Pellentesque at scelerisque est. Nulla vel mi ut magna commodo lobortis in ut diam. Etiam a lacus dui. Integer ut turpis arcu. In hac habitasse platea dictumst. Quisque porta neque at velit eleifend consequat. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Aliquam erat volutpat. Nam pretium turpis a sem placerat, non mollis diam dictum. Sed at nulla purus.
-
-Sed auctor neque nec consectetur sollicitudin. Donec aliquam arcu id diam commodo posuere. Nulla nec accumsan ante, at fringilla ligula. Sed nisi libero, iaculis ut convallis nec, ultrices ac ex. Mauris aliquam mi nec ultricies porttitor. Mauris malesuada odio ut hendrerit tempus. Aliquam non aliquam dui. Nam mi mauris, volutpat in ligula vel, blandit iaculis lectus.
-
-Integer vel maximus massa, sit amet mollis nibh. Proin at aliquet sapien. Nullam a turpis id libero facilisis dignissim. Sed convallis nulla vitae turpis consectetur, eu pharetra libero posuere. Interdum et malesuada fames ac ante ipsum primis in faucibus. Morbi venenatis massa id massa commodo suscipit. Cras magna lorem, porta eget velit at, vehicula semper velit. Maecenas cursus libero sit amet eleifend tempus. Suspendisse sed odio nisi. Suspendisse pulvinar felis semper magna hendrerit, ac posuere neque ullamcorper. Vivamus aliquam, elit id vulputate convallis, dolor lectus tempor nisi, id dapibus nulla eros in dui. Pellentesque ante libero, eleifend ac consequat vel, sodales in enim. Proin gravida sapien in nulla cursus, sagittis faucibus quam aliquam. Phasellus sit amet diam molestie, luctus urna eget, convallis elit. Nunc interdum erat fringilla, finibus neque quis, scelerisque justo. Donec interdum id risus at pharetra.
-
-Cras finibus magna turpis, sollicitudin viverra felis bibendum sagittis. Cras blandit facilisis euismod. Curabitur finibus enim gravida erat faucibus rhoncus. Aenean tempor elit vel sem ornare viverra. Ut at tortor nisl. Aenean in quam enim. Mauris pulvinar augue at nunc commodo, eget efficitur turpis laoreet. In vel fermentum nisi, eget porttitor diam. Mauris placerat eu ligula eu cursus. Curabitur ac tincidunt dolor, eu molestie est. Quisque ullamcorper vehicula faucibus. Phasellus euismod, arcu a scelerisque tempor, massa lectus ultricies velit, at mattis mauris mauris ultricies arcu. Proin condimentum ultrices nisl a rutrum. Proin bibendum sem quis accumsan fermentum.
-
-Integer sit amet velit sed urna rutrum molestie id non nunc. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Phasellus ac ornare dolor. Quisque ante massa, tincidunt eget iaculis sit amet, dapibus vitae arcu. Fusce sagittis leo eu varius egestas. Nam a ex non tellus vestibulum consequat sit amet ac est. Donec mi purus, varius non finibus sit amet, maximus ut mauris. Etiam a sapien lacinia, faucibus massa non, tempus libero. Aliquam ac lorem id purus vehicula consectetur quis non metus.
-
-Nam id imperdiet nulla, eu luctus sem. Nunc non risus vel quam dapibus porta. Aliquam laoreet dictum tristique. Curabitur et varius leo. Nulla hendrerit sem at tellus sodales, in porta nisl cursus. In et tincidunt tellus, vel commodo nulla. Etiam mattis dolor vestibulum libero aliquet, eget accumsan mi iaculis. Aenean in lacus congue, iaculis ipsum eu, condimentum ligula. Cras lorem leo, eleifend eget risus at, efficitur malesuada turpis.
-
-Suspendisse potenti. Pellentesque laoreet neque quis molestie finibus. Mauris id sapien in dui efficitur feugiat ut efficitur justo. Mauris quis faucibus ante. Suspendisse interdum sodales purus, sed semper ante venenatis vel. Aliquam rutrum, magna ut faucibus molestie, tortor ante iaculis nisi, in sollicitudin tellus arcu nec ex. Donec eu accumsan orci.
-
-Integer elementum metus rhoncus hendrerit molestie. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Mauris efficitur ultricies orci eget vulputate. Etiam pharetra sem lacus, eu convallis lacus fringilla vitae. Nunc accumsan volutpat tincidunt. Nam non mauris pretium urna iaculis venenatis. Aenean tempor tortor a urna eleifend maximus. Donec ornare dui non ornare bibendum. Phasellus suscipit posuere lacus ac vestibulum. Pellentesque sit amet eleifend quam, fermentum pharetra diam. Vestibulum in porta sapien. Aenean in rhoncus dui. Quisque euismod, metus non luctus vulputate, sem diam maximus lorem, porttitor volutpat est justo sed sapien. Etiam maximus eros eu elit cursus elementum.
-
-Nunc ut aliquet dolor. Nam nunc nibh, consequat non mollis eget, dignissim a sapien. Aenean luctus suscipit massa id pharetra. Vestibulum eget velit vitae lectus porttitor blandit vitae eget odio. Pellentesque ullamcorper finibus massa at pretium. Nunc nec sapien at lacus vehicula dictum sed quis elit. In vitae sem urna. Sed porttitor sodales ante, ut varius justo blandit eu.
-
-Proin faucibus tempus velit, nec bibendum mauris bibendum vitae. Sed auctor, massa feugiat tristique iaculis, massa dolor accumsan eros, feugiat blandit odio diam ut purus. In at magna semper, mollis risus et, viverra lectus. Ut diam nibh, ultrices id tellus eget, venenatis auctor orci. Praesent eget semper orci. Proin vel nisl leo. Nulla sit amet mi quis eros feugiat rutrum sed vel dolor. Ut ullamcorper ultrices est vel tincidunt. Mauris a tortor nec nibh egestas interdum et quis lectus. Etiam vitae rhoncus tellus. Quisque facilisis odio at justo tempus consectetur.
-
-Duis vitae diam nec odio pulvinar eleifend. Suspendisse convallis lacus sit amet nunc elementum sodales. Integer commodo accumsan lacinia. Aliquam dapibus dolor dolor, a laoreet augue finibus et. Integer faucibus sapien ac interdum lobortis. Vestibulum blandit varius eleifend. Nunc id lobortis ipsum. Nunc porttitor et risus quis interdum. Integer ante lectus, cursus et urna tincidunt, fringilla varius arcu. In bibendum quis turpis efficitur laoreet. Etiam sollicitudin dictum diam, euismod luctus ante varius sed. Cras vel hendrerit risus. Morbi et leo fermentum, tincidunt ligula ultrices, tempus arcu. Quisque non arcu at mauris luctus tempus eu vitae erat. Morbi ut est ac orci vulputate tincidunt id ac lorem.
-
-Mauris et sodales tellus. Curabitur metus orci, fermentum sed est in, porttitor fermentum mauris. Aliquam mollis elit nulla, in varius lectus tempus eget. Sed lacinia tempus lacus, sed pulvinar nulla congue a. In a congue est, vitae egestas nisi. Aenean interdum, leo ac fermentum suscipit, sapien dui luctus diam, non iaculis massa felis id ligula. Sed euismod placerat nunc quis tempor. Sed eu leo luctus, pretium elit vitae, laoreet dolor. Mauris aliquet ac lectus malesuada sagittis. Suspendisse placerat tincidunt nisi, id semper urna consequat at. Suspendisse sollicitudin eu augue sit amet faucibus. Ut vitae justo sagittis, euismod tortor vitae, ullamcorper dolor. Suspendisse ultricies at enim ac congue. Curabitur auctor neque lectus, nec condimentum sem eleifend et.
-
-Nullam id sem in risus vulputate facilisis. Sed iaculis ante sit amet iaculis luctus. Suspendisse ut aliquet sapien, eget hendrerit nisi. Ut malesuada velit dui, a egestas odio dapibus a. Phasellus rutrum sit amet dui vulputate ultrices. Maecenas iaculis ex eu tortor lacinia, consequat maximus mi tempus. Vestibulum neque odio, accumsan eu ornare ut, elementum sed lacus. Nulla ipsum leo, consectetur in ullamcorper sit amet, volutpat sit amet nulla.
-
-Praesent tincidunt, justo et venenatis mattis, enim ex lobortis elit, ut tristique dui eros eu urna. Suspendisse sodales tellus quam, nec hendrerit sem mollis vel. Duis nunc nulla, mollis eu nisl et, sagittis volutpat sem. Fusce dolor turpis, dapibus quis sollicitudin in, semper vitae felis. Fusce id ante velit. Praesent ac ornare velit. Proin non erat quis neque accumsan iaculis. Donec faucibus orci at malesuada finibus. Nam venenatis tempus venenatis.
-
-Aenean vel risus ultricies, tempor augue id, pretium diam. Aenean at nunc orci. Cras sit amet tortor eget arcu efficitur vulputate. Phasellus sed quam diam. Proin enim felis, luctus nec orci a, porta blandit tellus. Nulla ac erat suscipit, sagittis enim rutrum, scelerisque mi. Nullam vestibulum luctus lectus at cursus. Morbi ut orci lorem.
-
-Sed est justo, placerat id rhoncus eget, finibus vitae lectus. Aliquam ultricies porta nulla, eget aliquet ligula placerat a. Nulla suscipit laoreet elit. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc a arcu id nisi tincidunt ultrices vitae pharetra nisl. Quisque facilisis at dui vel dignissim. Etiam imperdiet in libero non venenatis. Vivamus consectetur lectus non ultricies laoreet. Aenean vel laoreet lectus, et laoreet tellus. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Etiam ex arcu, consequat eu diam non, tristique faucibus purus. Duis nisi elit, bibendum quis lacinia ac, fermentum a lorem. Suspendisse molestie nulla sed velit accumsan lobortis. Aliquam erat volutpat. In pharetra ultricies urna aliquet congue.
-
-Quisque ante metus, maximus et dui eget, sollicitudin accumsan risus. Ut malesuada neque et ex facilisis, sed egestas augue pellentesque. Suspendisse potenti. Nunc sapien libero, maximus vitae purus eu, lobortis sagittis diam. Aliquam ultricies vehicula lorem, sit amet vehicula dolor venenatis vitae. Phasellus consequat nisi ut quam tincidunt, eu bibendum nisi bibendum. Vivamus a interdum sapien. Vestibulum interdum pharetra molestie. Sed facilisis dui non velit malesuada, semper rhoncus sapien volutpat. Etiam arcu nisl, dignissim sit amet purus non, tempus finibus orci. Pellentesque viverra faucibus enim, eget dignissim justo accumsan ac. Quisque pellentesque orci nisl, in vestibulum massa auctor a.
-
-Pellentesque condimentum odio in turpis mattis, ac blandit dui commodo. Sed consectetur purus sit amet quam dapibus placerat nec ut orci. Maecenas mollis ex in mi commodo sodales. Sed est enim, consequat dapibus convallis quis, iaculis non dolor. Donec sagittis fermentum velit ut convallis. Nunc accumsan mi vel enim consequat commodo. Nunc varius id massa nec consequat. Donec purus sem, pellentesque gravida mollis ac, convallis a tellus. Praesent convallis massa lacus, eget pellentesque neque sodales nec. Sed ut velit diam. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Suspendisse lacus erat, mattis eu tellus sit amet, vehicula bibendum mi. Nam aliquam, nisi dapibus condimentum congue, ante mauris bibendum turpis, a consequat risus arcu eget felis. Aenean dictum, nisi in facilisis sollicitudin, felis diam convallis magna, eu pulvinar nisl odio quis massa. Suspendisse imperdiet tincidunt tortor, sit amet dignissim augue eleifend a. Vivamus consequat mauris vel tellus ullamcorper, in mattis ex auctor.
-
-Donec eros nunc, maximus non faucibus id, malesuada nec dui. Mauris rutrum accumsan nisi, volutpat tristique justo vulputate posuere. Vestibulum iaculis neque ut sapien sagittis, et volutpat erat finibus. Maecenas volutpat varius orci, ac lobortis justo fermentum vel. Ut nec tortor non erat sagittis dignissim at sed nunc. Sed porttitor dapibus velit a pretium. Proin id placerat magna, fringilla volutpat diam. Cras non ipsum non est porttitor fringilla eget sit amet turpis. Vestibulum vel pharetra nulla. Praesent ultricies mi urna, eget aliquam augue feugiat eu. Aenean efficitur ex ut luctus facilisis. Fusce leo odio, suscipit eget est eget, pretium posuere mauris. Fusce vulputate est sed felis mattis, at sollicitudin magna consequat. Aliquam erat volutpat. Mauris tincidunt tristique diam id tincidunt. Aenean sagittis dictum risus.
-
-Nunc vehicula mattis justo at placerat. Duis ultrices metus urna, et mollis erat blandit non. Pellentesque tincidunt vitae mi eget placerat. Nullam at condimentum arcu. Vestibulum sit amet orci et metus fringilla pretium ac ut magna. Suspendisse vitae accumsan orci. Donec convallis nunc odio, tincidunt volutpat tellus placerat ac. Phasellus sed bibendum eros, a auctor quam.
-
-Etiam sagittis accumsan sem ut interdum. Nullam eleifend eget felis in convallis. Donec sagittis enim interdum, suscipit metus ut, cursus orci. Integer vitae dapibus enim. Integer venenatis ligula ut lacus pretium, a pharetra massa posuere. Vivamus eu volutpat ipsum. Mauris tempus volutpat aliquet. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean ac odio bibendum, dictum neque sed, sollicitudin nulla.
-
-Quisque vulputate at ligula ut placerat. Morbi mollis ante id felis tempus consequat. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Maecenas eleifend odio a lectus sagittis, nec tristique ante egestas. Ut tempor, libero vel mattis interdum, risus quam condimentum turpis, nec viverra massa arcu ut turpis. Duis pharetra vehicula ligula, rhoncus commodo elit rutrum non. Nullam leo nisi, semper quis risus et, faucibus viverra odio.
-
-Quisque luctus nec arcu ut aliquam. Phasellus commodo ligula ut aliquet accumsan. Cras ac erat ac purus varius convallis. Vivamus nec gravida ipsum. Fusce euismod, massa ut cursus laoreet, eros urna semper odio, sed cursus turpis massa non lectus. Proin ac nisl lobortis, placerat elit in, placerat turpis. Nulla sollicitudin dolor ut sagittis consequat. Aenean augue felis, condimentum nec fermentum at, condimentum non nulla. Quisque et dignissim sapien, ac tincidunt elit. Nunc aliquet lacus id quam placerat suscipit. Mauris rutrum facilisis ipsum, at tristique mi. Sed iaculis eros sem, ut eleifend arcu hendrerit et. Sed euismod dignissim diam interdum ultrices. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed lobortis massa vel ultricies feugiat. Aenean non lobortis erat.
-
-Aenean commodo euismod massa vitae accumsan. Vivamus ac tristique mauris. Nunc hendrerit sapien a dictum scelerisque. Interdum et malesuada fames ac ante ipsum primis in faucibus. Quisque sit amet eleifend nulla, vel posuere lorem. Phasellus eu porta metus. Pellentesque eget sollicitudin dui, sed commodo magna. Integer tincidunt, diam vitae dapibus tincidunt, diam lorem rutrum erat, ut consequat ex metus sed leo.
-
-Suspendisse odio metus, suscipit at congue at, consectetur auctor justo. Integer vel rutrum lacus. Quisque a ullamcorper ligula, nec placerat arcu. Ut hendrerit orci sit amet leo pellentesque iaculis. Integer neque erat, dapibus vel pharetra ut, sagittis id diam. Duis eget ex felis. Donec eget odio in sem hendrerit varius. Sed malesuada euismod erat. Sed bibendum malesuada lacus at euismod. Ut ornare pretium imperdiet. Maecenas ut orci id massa lobortis pulvinar vitae et neque. Nullam iaculis dictum sagittis. Vivamus vel finibus libero, eget congue ligula. Etiam faucibus orci felis, eu accumsan enim sollicitudin at. Donec accumsan libero at pharetra malesuada.
-
-Nullam luctus, metus eu varius dignissim, lectus neque aliquet massa, nec pellentesque ligula ligula vel leo. Cras rutrum eleifend viverra. Sed lobortis eget erat tincidunt imperdiet. Nullam ac fringilla urna. Fusce pretium, lorem ac mollis semper, sem felis ornare odio, eget feugiat dolor orci ut dui. Curabitur ac odio mollis, convallis ex eget, hendrerit nulla. Nunc vel turpis nisl. Ut neque urna, fermentum interdum est non, lobortis luctus elit. Phasellus bibendum malesuada gravida. Phasellus lacinia scelerisque erat sit amet iaculis. Nulla in ultricies lectus.
-
-Praesent blandit ante congue urna eleifend porta. Nulla sagittis urna quis molestie viverra. Praesent in lorem porttitor, vestibulum orci hendrerit, faucibus enim. Donec sapien enim, porta at sapien eget, condimentum mattis dui. Aliquam rhoncus dui elit, non laoreet ex condimentum ut. Nam arcu sem, suscipit quis diam vel, pharetra bibendum ligula. Duis vel ipsum gravida libero iaculis feugiat. Aliquam congue augue mi, gravida dignissim ipsum commodo id.
-
-Suspendisse vel tincidunt odio. Donec quis hendrerit felis, sed sagittis mi. Cras ultricies justo et ligula dignissim, ac porta nisi maximus. Suspendisse vitae facilisis sapien, ut consequat lacus. Morbi dapibus in diam in tempus. Curabitur viverra leo libero, et molestie lacus interdum eu. Donec ut odio sit amet nisl viverra fermentum eget eget sem. Donec id ante consectetur, porta velit a, consectetur mauris. Donec imperdiet dolor turpis, at maximus purus volutpat ac. Ut hendrerit eros sit amet mi porttitor, nec ultrices purus posuere. Etiam elementum mauris ligula, nec viverra neque luctus quis.
-
-Donec ultrices lectus nec sollicitudin egestas. Mauris ac lacinia mauris. Proin accumsan leo et quam venenatis mattis. Pellentesque laoreet interdum feugiat. Phasellus arcu justo, blandit vel faucibus vel, maximus in sapien. Mauris semper, leo quis accumsan tristique, arcu massa tempus sapien, nec luctus turpis mi id enim. Donec egestas consectetur augue non viverra. Mauris pellentesque turpis non ante posuere, bibendum laoreet nunc semper. Aliquam accumsan semper nulla, sed tincidunt nulla pretium id. Mauris ut sapien vel felis pharetra congue. Curabitur ac euismod risus.
-
-Integer a lectus lorem. Phasellus a sodales odio. In consectetur bibendum ex eu blandit. Nam eu feugiat sapien, id efficitur orci. Quisque fermentum sem eget orci mattis tristique. Donec sit amet pharetra massa. Pellentesque molestie, neque a viverra dignissim, magna quam sagittis ligula, at tincidunt tellus risus quis enim. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Praesent scelerisque faucibus nunc eget consequat. Fusce aliquet egestas eros quis auctor.
-
-Sed aliquam mauris non lacus rhoncus, id eleifend nunc ullamcorper. Nulla cursus erat non purus gravida, porta ultricies libero vestibulum. Nulla sagittis metus eleifend porttitor molestie. Suspendisse rutrum consequat ullamcorper. Ut pellentesque dolor eget gravida cursus. In posuere, ipsum nec pulvinar varius, massa odio aliquam mauris, vitae facilisis ligula orci quis augue. Pellentesque a tortor ultricies, ullamcorper libero ut, ullamcorper augue. Nullam id felis non dui viverra placerat id eu metus. Aenean ac dui condimentum, dapibus tellus non, blandit ex. Maecenas et odio vitae massa gravida consequat eu sed nunc. Nullam laoreet, nisi sed imperdiet laoreet, sapien nisl aliquam augue, vitae ornare velit ligula id neque. Ut tincidunt, lacus at porta ultricies, tellus felis fringilla dolor, tempus posuere nibh nisi eu felis. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae;
-
-Proin ac nulla turpis. Aenean pretium congue viverra. Donec vitae sem venenatis, luctus lacus non, rhoncus purus. Etiam sit amet lorem consequat, mollis nibh quis, congue neque. Sed vulputate justo quis porttitor malesuada. Nullam id ex sit amet ante aliquet tincidunt. Praesent pretium maximus orci ut cursus.
-
-Mauris vitae aliquam magna. Sed quis ante cursus, dapibus risus vel, tristique nisi. Fusce suscipit porta quam, vel vestibulum ligula dapibus vel. Nunc consequat eu mi at aliquam. Donec sit amet dolor nulla. Praesent gravida tellus enim, in porttitor sem scelerisque vitae. Nullam consequat, nunc eu iaculis tempor, sem augue placerat ex, sed ultrices erat nisi a tellus. Nunc tortor nisl, feugiat lobortis rutrum ut, pharetra ac nulla. Donec eu tortor eros. Proin maximus nisl sit amet velit accumsan facilisis. Praesent posuere tristique faucibus. Vivamus nec hendrerit tellus, id vulputate eros. Aliquam a lacus efficitur, consectetur ipsum eu, ullamcorper ex. Aliquam erat volutpat.
-
-Vivamus ultrices scelerisque elit, ac ultrices erat consequat id. Sed ac aliquet nulla. Pellentesque vel justo magna. Suspendisse dictum, sem eget ullamcorper iaculis, sapien metus tristique mauris, et dictum elit eros sit amet ex. Mauris placerat odio eu ligula egestas sagittis. Integer vel turpis lacinia tortor molestie egestas et id dui. Donec porta interdum justo, ac ornare lacus dictum at. Quisque mollis, odio sed eleifend rhoncus, purus turpis fringilla quam, ac fermentum enim ante sed massa.
-
-Vestibulum neque ipsum, congue vel lacus et, faucibus mattis sem. Ut venenatis, tortor non tincidunt mollis, sapien leo suscipit dolor, posuere tristique libero massa eu augue. Donec eu luctus velit. Nulla egestas, tellus sed commodo gravida, metus nibh placerat sem, nec mollis nulla nunc id lorem. Nulla facilisi. Donec ut tincidunt sapien. Quisque dapibus convallis interdum. Nulla tempor malesuada turpis non vehicula. In nec tortor ultrices, vestibulum odio non, ultrices sapien. Pellentesque mattis feugiat arcu, id tincidunt leo malesuada at. Fusce vitae pretium ante. Pellentesque eu augue non lectus efficitur rutrum. Cras vitae nisl elementum, congue est eget, faucibus quam. Donec in dapibus metus.
-
-In imperdiet metus eget leo rhoncus, et pharetra dui laoreet. Morbi arcu augue, eleifend a est eget, gravida suscipit risus. Ut sodales ex vel eleifend bibendum. Nam varius nisl sit amet dolor porta pulvinar. Ut mollis purus sit amet tempus vulputate. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Curabitur a lacinia velit, in feugiat elit. Sed ut vestibulum lorem. Proin fermentum elit quis venenatis placerat. Cras sit amet congue tortor. Curabitur eget sapien massa. Suspendisse in turpis arcu.
-
-Quisque vitae risus scelerisque, rutrum tellus et, posuere massa. Vestibulum vitae rhoncus libero, vel ultrices elit. Vivamus nec ipsum ac urna tristique sollicitudin non nec tellus. Donec bibendum dui eget ipsum laoreet, sed tincidunt tellus laoreet. Proin in rhoncus nibh. Integer vel quam id felis interdum aliquet. Nulla tempus volutpat consequat. Suspendisse nec massa malesuada, finibus est non, eleifend odio. Aliquam libero turpis, consequat vel pellentesque vitae, laoreet vitae tellus. Donec finibus diam id accumsan luctus.
-
-Cras at lorem ligula. Praesent tincidunt justo eu purus suscipit ornare. Morbi malesuada dui non ligula congue, ac fringilla diam commodo. Proin vel arcu non tortor tempus lacinia eget ut arcu. Sed tristique lorem et purus tristique, nec ultrices tortor lacinia. Nunc id nibh id mauris volutpat rutrum at in nisl. Cras in cursus lectus, nec fermentum dolor. Morbi at tempus tortor. Aenean pulvinar ex erat, vitae aliquet nisl finibus at. Praesent pellentesque tempor imperdiet. Aliquam eu aliquet purus. Maecenas hendrerit volutpat ultrices. Aliquam metus tellus, porttitor sit amet sem ut, bibendum ultricies urna.
-
-Cras accumsan lacus ac ullamcorper tincidunt. Fusce imperdiet nunc vel diam condimentum, viverra dignissim magna mollis. Aliquam rutrum gravida libero non congue. Morbi pretium, nulla ac eleifend sodales, dolor orci feugiat ipsum, ut posuere dolor augue quis mauris. Cras tincidunt enim dui, at porta orci consectetur vel. In id purus ante. Donec luctus mattis dictum. Curabitur tortor orci, accumsan finibus sodales ac, maximus eget purus. Suspendisse efficitur vitae dui ut faucibus. Integer bibendum ipsum massa, sagittis posuere sapien elementum at. Vivamus tristique at quam id congue. Maecenas eu augue vel erat varius congue at id quam.
-
-Sed tristique nisl elit, finibus venenatis urna facilisis id. Integer cursus interdum justo, et viverra diam interdum quis. Sed in vestibulum arcu. Pellentesque elementum ex vitae diam tincidunt bibendum. Nunc eu mi suscipit, faucibus metus sit amet, tincidunt dolor. Integer vulputate sodales luctus. In ut scelerisque sem, sed egestas eros. Etiam lobortis diam ac augue pulvinar, eu aliquam massa blandit.
-
-In dui magna, faucibus at purus in, sagittis dapibus diam. Cras commodo massa tortor, eu consequat libero placerat eu. Ut mauris metus, facilisis et erat sed, rhoncus maximus nisl. Sed ac aliquet nisi. Aenean in rhoncus velit. Sed mollis, nunc vitae imperdiet pharetra, arcu ex pulvinar nibh, ac rhoncus lectus enim nec erat. Donec rutrum molestie nibh et lobortis. Proin nec nibh in ex pretium ultrices non et arcu. Nam consequat tempor viverra. Fusce vitae pharetra diam, ac bibendum ex. Quisque cursus, tellus ac interdum accumsan, lectus nunc lobortis elit, id varius orci diam a metus. Etiam at mauris vitae metus ullamcorper bibendum nec sed leo. Pellentesque eu arcu varius, imperdiet ligula non, maximus tellus. Aliquam erat volutpat.
-
-Curabitur fringilla ligula in consectetur varius. Donec eget tortor ex. Nunc quis lacus lobortis, vulputate lorem eu, scelerisque sapien. Aliquam non pretium ante. Aenean maximus ornare eros, ut condimentum nibh pulvinar eu. Morbi venenatis sollicitudin justo, non tincidunt ligula lacinia vitae. Nam vitae quam ligula. Fusce in finibus urna, a laoreet dui. Quisque urna arcu, aliquam sed dolor quis, pellentesque convallis risus. Vestibulum faucibus maximus justo, eget gravida elit tincidunt quis. Cras in arcu dui. Aliquam eu nibh gravida, lacinia ipsum sit amet, scelerisque nisl. Integer luctus sagittis mattis. Etiam dolor sapien, dapibus at neque nec, rhoncus scelerisque odio. Pellentesque laoreet justo ac augue eleifend placerat. In vitae hendrerit ex.
-
-Nam sit amet dui in libero volutpat lacinia. Quisque vel luctus purus. Aenean arcu magna, luctus sed interdum vitae, elementum quis eros. Mauris aliquet diam mi, ut tincidunt magna consequat quis. Cras vitae lacus posuere urna pretium lacinia. Fusce ultricies maximus hendrerit. Donec et augue quis lectus lacinia accumsan. Nunc tortor neque, vestibulum porta bibendum id, varius quis sapien. Vestibulum et ultricies odio, id pharetra lacus. Suspendisse sollicitudin nisl nec justo fermentum, vitae volutpat lectus aliquam. Duis blandit quam at erat sodales, ut suscipit erat aliquet. Fusce faucibus dui enim, eu varius neque imperdiet id. Vestibulum dapibus neque libero, vitae viverra erat mattis id. Quisque ullamcorper diam ut porta finibus. Donec faucibus, diam quis pellentesque euismod, enim velit mattis justo, at ultricies urna enim ac leo.
-
-Fusce fringilla dolor sit amet ante pharetra ornare. Aliquam erat volutpat. Donec laoreet, lorem nec pulvinar ullamcorper, urna justo bibendum nunc, in laoreet nisl tortor vel justo. Donec a magna molestie, gravida tortor a, malesuada tortor. Praesent vestibulum ultricies metus, vitae fringilla tellus viverra sed. Suspendisse sed odio sit amet nibh ultricies interdum accumsan egestas ex. Fusce ac lacus arcu. Ut ultricies at justo elementum mattis. Nullam augue tortor, lacinia tempor turpis a, porta finibus neque. Donec id diam tristique arcu vestibulum fermentum vitae id tellus. Vestibulum sit amet ligula neque. Aliquam neque ante, ultricies nec diam malesuada, feugiat consequat risus. Pellentesque ac varius orci.
-
-Etiam nunc ex, laoreet eget eros ut, ultricies fermentum sem. Nullam venenatis diam a lectus vulputate luctus. Integer laoreet libero et tellus fermentum, ut maximus neque tristique. Ut in odio posuere, lobortis augue non, tristique orci. Quisque vel ultricies mauris, non consectetur enim. Sed dictum vitae felis vel scelerisque. Vestibulum id viverra leo. Etiam libero neque, cursus eu augue eget, fringilla luctus arcu. Donec aliquet maximus ipsum, ut faucibus velit posuere non. Praesent finibus erat nec massa cursus, ac blandit ante bibendum. Ut vel magna pretium, interdum quam non, sodales erat.
-
-Sed et orci nunc. Vestibulum elit sem, dapibus id dictum eu, interdum sit amet justo. Morbi interdum hendrerit tempus. Quisque id magna justo. Donec sollicitudin, nunc a efficitur hendrerit, mi neque semper nisl, sed consectetur urna justo vel velit. Nullam at sodales eros. Donec eu nunc vel dui tristique blandit ut eget enim.
-
-Nulla velit neque, euismod vitae lectus vel, finibus egestas magna. Ut sed justo sed erat pretium sollicitudin nec nec felis. In mattis augue ut erat mollis, in posuere purus tincidunt. Vivamus rhoncus sem at purus gravida, et vestibulum justo elementum. Aenean sit amet elit ac ligula tincidunt varius. Donec feugiat, orci vel interdum lobortis, elit magna fringilla nulla, non euismod urna dolor auctor est. Mauris laoreet sagittis ligula, et semper nisi finibus et. Donec pharetra nibh in eros iaculis aliquam. Nam malesuada ornare elit, ac semper massa molestie sed. Maecenas laoreet diam eu ipsum rutrum, ut varius enim bibendum. Donec luctus dolor eu ipsum varius, malesuada condimentum sapien tempor.
-
-Aenean vel rhoncus lacus, sit amet faucibus nisl. Aliquam laoreet nisl et diam eleifend molestie non vel lectus. Duis tortor augue, congue luctus malesuada sit amet, posuere mattis mauris. Aliquam quis ligula ut ipsum placerat luctus. Aliquam accumsan mauris ligula. Sed quis lacinia augue. Proin feugiat diam lectus, vel elementum libero varius non. Proin porta neque sed dolor gravida venenatis. Donec vitae euismod nibh. Morbi mattis, enim quis mattis dignissim, lacus tellus tristique nisl, in luctus leo nisl vel elit. Sed posuere justo in iaculis mattis.
-
-Curabitur in felis et metus blandit auctor ac in nulla. Vestibulum dictum nulla posuere augue ultrices, non gravida velit placerat. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. In malesuada pharetra ante sit amet sodales. Suspendisse et tincidunt lorem. Interdum et malesuada fames ac ante ipsum primis in faucibus. Integer viverra justo ut nisi elementum dictum. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Nullam dictum tincidunt venenatis. Aliquam neque urna, pellentesque vitae ultrices eget, lobortis sed augue. Etiam at ex ultricies, egestas dui sit amet, laoreet lorem. Ut nulla velit, bibendum in arcu sed, dignissim mattis odio. Suspendisse varius dictum vulputate. Sed nisl tellus, eleifend quis augue ac, malesuada elementum arcu.
-
-Morbi dignissim laoreet imperdiet. Vivamus tincidunt turpis quis posuere mattis. Nam mollis, elit eget lacinia auctor, lorem magna mattis elit, eget pulvinar mauris quam sed turpis. Suspendisse nibh libero, volutpat nec metus tempus, euismod lobortis sapien. Pellentesque interdum urna a leo dignissim lobortis. Suspendisse quis diam pretium, vehicula augue eget, sodales nibh. Cras dignissim lorem ac velit mollis, ac hendrerit urna varius. Fusce venenatis elit ut mauris volutpat, sed imperdiet arcu pellentesque.
-
-Phasellus auctor nec ex eu tempor. Quisque ut elit eget ligula euismod pretium. Quisque ac lectus et est fringilla convallis. Mauris tincidunt turpis non ullamcorper suscipit. Suspendisse consectetur lacus at lacinia iaculis. Morbi purus metus, tincidunt ac ultricies a, rhoncus varius magna. Suspendisse mattis vehicula enim at ultrices. Phasellus eu ipsum nisi. Duis dignissim massa non convallis rutrum. Sed placerat consectetur ex, quis malesuada lectus cursus a. Nulla non mi egestas, scelerisque urna vitae, pulvinar libero. Vestibulum pretium purus at odio pharetra, ut egestas nibh pretium.
-
-Nulla facilisi. Duis in augue eu elit accumsan imperdiet a a odio. Curabitur vitae ante in velit condimentum venenatis id vitae mi. Sed in ante fringilla, mollis metus vel, consectetur nisi. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nulla non dolor congue neque dapibus varius. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Aliquam sit amet convallis velit. Praesent a efficitur massa, non finibus ex. Maecenas pharetra elit eget sem rhoncus, vel mollis eros pretium. Donec vehicula dolor a nulla ornare, at lacinia ex venenatis.
-
-Suspendisse aliquam blandit est, rutrum luctus turpis cursus vitae. Pellentesque in magna eget risus egestas rhoncus. Maecenas sed odio non ex interdum eleifend mollis convallis neque. Quisque a orci fringilla, maximus arcu id, rhoncus magna. Aenean at aliquam est. Aenean faucibus consequat tempus. Aliquam congue viverra ante, non aliquet sapien viverra ac. Etiam ullamcorper neque in metus malesuada suscipit. Curabitur quis placerat mi.
-
-Integer at mauris ut lacus vulputate mattis sit amet at purus. Proin arcu nisl, lacinia eu venenatis ac, mattis ut velit. Suspendisse elementum mattis mauris, in faucibus lorem. Suspendisse bibendum nulla in commodo ultrices. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Vivamus iaculis volutpat mattis. Pellentesque ut ex interdum, consequat diam egestas, blandit nisi.
-
-Nullam odio turpis, pretium ac ante porttitor, fringilla lacinia ante. Fusce commodo quam vel dui blandit, nec eleifend tellus aliquam. Fusce sodales efficitur urna, vitae vehicula erat lacinia eu. Praesent maximus nunc id sapien feugiat, in euismod nibh rutrum. Vivamus at volutpat libero. Praesent quis mattis mi. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. In hac habitasse platea dictumst. Integer quam odio, pharetra nec molestie porttitor, auctor at ligula. Fusce id turpis non tellus facilisis tincidunt.
-
-Morbi lorem risus, sagittis sit amet venenatis sit amet, lacinia at dui. Vestibulum volutpat, urna ac ultrices efficitur, tortor augue convallis dolor, nec commodo arcu arcu id ante. Quisque facilisis mauris in molestie tincidunt. Fusce aliquet sagittis interdum. Vivamus sit amet odio nec augue volutpat placerat non nec nibh. Nunc auctor purus eu dignissim euismod. Ut sollicitudin urna et erat placerat, vel accumsan lectus malesuada. Proin fringilla magna sit amet massa dignissim lobortis ut ac felis. Donec ornare dignissim tristique. Phasellus semper, est sit amet vestibulum suscipit, arcu est elementum nulla, in sagittis sapien ligula a sem.
-
-Morbi at justo molestie, gravida lacus quis, placerat est. Mauris non libero ultricies, convallis dui et, scelerisque est. Nunc iaculis, libero sed ullamcorper feugiat, eros ante lacinia ex, vel efficitur velit arcu eu metus. Quisque fermentum blandit fermentum. Vestibulum quis ante in dolor porta efficitur eu nec libero. Mauris vitae ex mattis mi fringilla pharetra. Donec eget est nec lorem pretium pretium. Fusce eget risus eros. Vivamus eu nulla et libero tincidunt malesuada at ac dolor. Donec facilisis tempus sem, in posuere orci sagittis vel. Donec pellentesque sapien mi, eu tempus enim tempor vel. Cras consequat purus sed ornare vehicula. Nunc molestie eu ex et fermentum. In vestibulum, arcu nec cursus efficitur, leo ex fringilla neque, in molestie nisl diam mattis sapien. Nunc et semper ante.
-
-Sed pellentesque laoreet sollicitudin. Ut sed ex eu sapien bibendum posuere. Mauris non sem dui. Fusce sit amet nulla a tortor blandit blandit. Proin venenatis ligula quis sapien viverra accumsan. Proin ac turpis a dolor rhoncus facilisis eget vel ipsum. In gravida porttitor quam, quis dignissim lacus laoreet porta. Nulla ante risus, luctus at pharetra vitae, vehicula id elit. Etiam sagittis dui vitae metus mollis, in porttitor elit fringilla. Duis dapibus dignissim faucibus. Duis elementum facilisis leo eget ornare. Cras feugiat libero at efficitur tempus. Suspendisse sit amet laoreet nunc, at faucibus tellus. Vestibulum in ipsum ac risus vehicula porta. Fusce maximus libero mattis risus aliquam condimentum. Fusce ut consectetur risus, a fermentum arcu.
-
-Curabitur hendrerit eu lacus non congue. Fusce ac dictum magna. Nulla elit ante, sodales sed lobortis sodales, fermentum vitae urna. Cras pharetra vel sapien dignissim ullamcorper. Phasellus auctor elementum suscipit. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec lacus odio, venenatis lobortis ullamcorper et, tempor nec augue.
-
-Mauris scelerisque vestibulum metus, vitae porta sem pharetra nec. Nam tempus dolor sed turpis lobortis sodales. Vestibulum nec mauris auctor velit pellentesque vestibulum tristique vel eros. Vivamus vel justo vel dui lobortis dapibus a at sapien. Maecenas ac metus nec tortor vulputate laoreet in nec augue. Aliquam tellus leo, imperdiet non dapibus a, facilisis non tellus. Suspendisse condimentum tincidunt lacus, ut scelerisque diam viverra nec. Etiam ante mauris, viverra sit amet vulputate ut, porta a ligula. Donec sit amet luctus massa. Morbi iaculis, tortor sit amet ullamcorper iaculis, mauris augue feugiat risus, eu bibendum dui tellus nec purus. In gravida sodales egestas. Sed tincidunt pellentesque tincidunt. In non neque non erat mattis iaculis. Cras et ipsum justo. Phasellus ex elit, dictum ut nulla et, consectetur auctor lectus.
-
-Donec vitae velit nisi. Cras lobortis a nisi eu molestie. Nunc mattis arcu id neque aliquam, quis sollicitudin lectus lobortis. Donec nec convallis purus, eget sagittis sapien. Maecenas viverra ullamcorper quam in vehicula. Pellentesque imperdiet nisl in elit varius, eu fringilla orci ullamcorper. Donec blandit ultrices volutpat. Nulla nec tempor mi, ac finibus nisl. Phasellus et urna non lorem tincidunt pulvinar nec nec ligula. Ut hendrerit volutpat diam. Morbi vel sollicitudin libero, ac molestie purus. Nulla sit amet metus ut leo molestie faucibus. Nunc porttitor, est in pulvinar vestibulum, justo nibh placerat ipsum, at interdum metus mi vitae dui. Curabitur in egestas nunc. Ut malesuada ipsum sed velit rutrum accumsan ac in quam.
-
-Quisque ex est, fermentum vitae placerat sit amet, porta ac nulla. Morbi accumsan tellus quis dolor cursus, in elementum sapien condimentum. In non dui ultrices, sagittis dui quis, blandit nunc. Curabitur blandit justo sed tincidunt imperdiet. Sed a odio aliquet, gravida augue non, faucibus magna. Phasellus pulvinar volutpat sem, ut bibendum nibh semper eu. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Curabitur at tellus in nulla vulputate feugiat vitae id dui. Suspendisse nec velit ac arcu fringilla venenatis. Duis urna massa, eleifend sit amet venenatis in, lobortis ac odio. Aliquam blandit vitae ipsum quis tempor. Curabitur a interdum sapien, vitae tempus arcu. Maecenas condimentum, justo vel rhoncus facilisis, lectus nisl commodo massa, eget maximus odio enim sit amet libero. Morbi at erat purus. Aenean dictum diam ut lorem venenatis consectetur. Praesent sit amet dolor eget lectus mollis tempus ac sit amet diam.
-
-Maecenas at convallis magna, nec iaculis metus. Quisque pulvinar ultricies vehicula. Aliquam quis tortor in elit semper tincidunt. Nullam aliquet ex dapibus lorem mattis gravida. Suspendisse volutpat, nibh sit amet efficitur egestas, lorem justo convallis enim, nec efficitur nunc mauris vel nisl. Sed condimentum ac justo sit amet accumsan. Suspendisse ultricies dolor nulla, at euismod nisl semper eu. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos.
-
-Donec hendrerit, ex non tincidunt molestie, lacus mauris euismod risus, vitae suscipit sem orci et risus. Donec sollicitudin eros non ante gravida aliquam. Etiam at augue risus. Mauris vitae ante ac eros sodales ornare non in enim. Fusce consequat tortor urna. Aenean condimentum neque quis viverra interdum. Aliquam ultricies convallis ipsum, nec lacinia massa bibendum nec. Suspendisse ac ultricies diam, sit amet mollis mi. Mauris at tincidunt elit. Morbi fringilla nisl ligula, nec scelerisque magna viverra non. Aliquam aliquam porttitor eros, cursus congue eros maximus vel.
-
-Pellentesque mattis sapien eu scelerisque feugiat. In hendrerit rutrum sem vel convallis. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Sed varius velit et erat lacinia ornare ut sed nibh. Nam imperdiet hendrerit urna, ultricies dapibus elit blandit sit amet. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aliquam porttitor, purus scelerisque ornare aliquam, massa nulla semper erat, sit amet cursus diam risus vitae mauris. Ut rhoncus pellentesque elementum.
-
-In a ipsum in dui venenatis scelerisque ut a ante. Quisque tincidunt turpis vitae arcu rhoncus, quis maximus nisl venenatis. Sed ac tortor et nibh aliquam posuere. Praesent ipsum tortor, scelerisque nec sem vitae, efficitur mollis lacus. Sed dui tellus, mattis eu turpis in, accumsan mattis elit. Donec eu nunc dolor. Ut ornare dui quis tortor hendrerit ornare. Sed finibus ornare nulla, vitae vehicula urna vestibulum at. Integer fermentum diam sit amet congue suscipit. Donec massa lectus, dignissim ut metus eu, vehicula dictum nisi.
-
-Phasellus ligula tortor, consequat a urna quis, interdum congue libero. Sed condimentum sapien sed gravida tristique. Suspendisse vel condimentum orci. Pellentesque pharetra hendrerit malesuada. Morbi commodo ut quam et iaculis. Ut finibus dapibus metus, ut varius orci dapibus non. Nunc efficitur efficitur ultricies. Sed laoreet quam vel volutpat laoreet. Nullam placerat suscipit neque at aliquet. Curabitur luctus nisi eget rutrum interdum. Nam lacinia turpis sed massa euismod tincidunt. Aenean odio nisi, hendrerit et lacus et, sodales mollis leo. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Donec posuere erat nibh, a tristique quam bibendum sed.
-
-Nulla vestibulum leo laoreet, mattis purus at, tempus dolor. Morbi nibh lacus, vehicula eu nibh vel, pellentesque pulvinar magna. Suspendisse urna lorem, pretium non lorem eu, maximus porttitor eros. Integer in purus consectetur, pretium massa ac, bibendum quam. Vivamus venenatis finibus feugiat. Donec ornare neque eu convallis varius. Nullam sodales, tortor id semper varius, nibh odio tincidunt mi, vitae gravida purus erat nec libero. Nam varius tincidunt maximus. Nunc quis metus a diam porta tincidunt ac quis ex. Nunc bibendum nisl tortor, interdum luctus augue suscipit et. Phasellus pretium egestas aliquam. Maecenas in libero enim.
-
-Duis lacinia dolor eu nunc viverra, quis blandit nunc posuere. Suspendisse ultricies ultrices tincidunt. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Proin imperdiet finibus dui, sed vehicula ligula semper vitae. Vestibulum elementum a ante quis vestibulum. Integer sit amet ullamcorper sapien. Cras sapien odio, commodo at consequat non, auctor volutpat ante. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Maecenas ut congue urna, eu iaculis lectus. Curabitur consequat, lectus non pharetra ultricies, massa sapien pellentesque lectus, eu laoreet elit turpis et sapien.
-
-Pellentesque vel vehicula arcu. Proin aliquam hendrerit turpis aliquam ultrices. Nunc pellentesque urna tempor ipsum porta faucibus. Morbi lobortis quam eget lacus tempor, tempor commodo justo molestie. Suspendisse cursus turpis diam, eget pulvinar velit dignissim ut. Donec vulputate sodales justo ac hendrerit. Donec ultricies mauris id lorem bibendum pulvinar. In sed dictum ex. Phasellus sit amet lacus eget risus scelerisque congue id vitae ex. Vestibulum pellentesque rhoncus lacus, non lobortis dui faucibus non. Cras efficitur dictum rutrum. Pellentesque euismod id felis sit amet faucibus. Maecenas tristique urna ac mi tristique, ac varius ante cursus.
-
-Vestibulum eu mi sed felis consequat fermentum. Duis sit amet nulla a diam maximus tristique. Sed in turpis diam. Cras sodales egestas massa. Maecenas eget dui tellus. Quisque vulputate tellus sem, non dictum nisi feugiat eget. Suspendisse interdum urna id quam facilisis tristique. Proin dolor ex, vestibulum quis dui ac, dignissim blandit dolor. Sed nec interdum ante. Nullam fermentum iaculis augue ut sodales. Mauris dapibus interdum maximus. Aliquam laoreet nisl et tellus congue, nec molestie justo hendrerit. Suspendisse eros libero, semper a nulla a, placerat convallis leo. Ut ornare turpis velit, id ultrices nulla lobortis non.
-
-In hac habitasse platea dictumst. Etiam condimentum, nunc vitae faucibus mattis, diam neque accumsan urna, eu tincidunt augue odio sit amet metus. Quisque at mauris eget purus ultricies ultricies vel eget ligula. Phasellus tortor urna, vestibulum eget tincidunt ut, malesuada nec ligula. Phasellus congue dignissim erat ut lacinia. Duis massa lacus, placerat quis ipsum sit amet, maximus ornare velit. Nulla commodo, urna maximus vehicula suscipit, arcu elit commodo leo, ut luctus mauris ipsum sit amet turpis. Donec ornare dignissim tincidunt. Duis efficitur tristique eros, bibendum mattis lorem auctor sit amet. Donec fermentum imperdiet venenatis. Praesent scelerisque purus in scelerisque dignissim. Nulla eu rhoncus nisl.
-
-Integer quis orci in nisl egestas porta vel efficitur ligula. Sed urna nibh, efficitur ac odio eget, rhoncus viverra magna. Nunc at luctus velit. Nullam laoreet, diam non semper faucibus, purus nisl sagittis mauris, in fringilla dolor sapien et massa. Duis rhoncus lectus nibh, in molestie ante consequat vitae. Fusce a enim vel justo posuere tempor. Interdum et malesuada fames ac ante ipsum primis in faucibus. Pellentesque eget mi id nulla tristique pellentesque. Aenean lacinia metus lacus, eu viverra turpis interdum at. Aliquam ut convallis mauris. Donec scelerisque ex nulla, id convallis magna vehicula auctor. Maecenas aliquam, felis dapibus convallis congue, odio nisl accumsan dui, vel molestie ex massa quis metus. Vestibulum id vulputate justo. Sed aliquet, est quis varius scelerisque, erat lorem mattis lorem, in sollicitudin risus lorem a justo. Praesent fermentum posuere turpis, vitae fermentum velit rhoncus ut.
-
-Quisque pellentesque urna vehicula est vestibulum blandit. Donec molestie sagittis erat, sed interdum est dignissim a. Fusce accumsan orci mauris, quis feugiat sem consequat sit amet. Nulla ultricies euismod molestie. Proin eleifend sodales diam vitae facilisis. Nullam sit amet urna tortor. Sed laoreet sapien eu quam cursus eleifend. Praesent vulputate metus turpis, quis aliquam enim semper ut. Donec dignissim libero quis magna euismod faucibus. Nulla aliquam ante id enim consectetur placerat.
-
-Fusce ullamcorper tellus id pulvinar dignissim. Nam sagittis luctus ipsum, non dictum urna pulvinar quis. Nunc hendrerit quam eu dui egestas, vitae semper sem vestibulum. In efficitur ligula ante, nec faucibus libero tristique ac. Suspendisse potenti. Ut vestibulum massa erat. Proin ornare mi et est varius, in fringilla mi laoreet. Sed libero nisi, gravida sed felis sit amet, bibendum semper risus. Curabitur luctus nunc vulputate elementum cursus.
-
-Aliquam feugiat, est sed congue fermentum, nibh dolor suscipit nunc, sed porttitor velit dui quis eros. Nam aliquet neque sed faucibus sagittis. Ut iaculis dictum odio in vestibulum.`
diff --git a/fileTransfer2/params.go b/fileTransfer2/params.go
deleted file mode 100644
index 4a70046560b0e2793620f8bf29d5c1c62078b6f1..0000000000000000000000000000000000000000
--- a/fileTransfer2/params.go
+++ /dev/null
@@ -1,92 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package fileTransfer2
-
-import (
- "encoding/json"
- "gitlab.com/elixxir/client/cmix"
- "time"
-)
-
-const (
- defaultMaxThroughput = 150_000 // 150 kB per second
- defaultSendTimeout = 500 * time.Millisecond
-)
-
-// Params contains parameters used for file transfer.
-type Params struct {
- // MaxThroughput is the maximum data transfer speed to send file parts (in
- // bytes per second). If set to 0, rate limiting will be disabled.
- MaxThroughput int
-
- // SendTimeout is the duration, in nanoseconds, before sending on a round
- // times out. It is recommended that SendTimeout is not changed from its
- // default.
- SendTimeout time.Duration
-
- // Cmix are the parameters used when sending a cMix message.
- Cmix cmix.CMIXParams
-}
-
-// paramsDisk will be the marshal-able and umarshal-able object.
-type paramsDisk struct {
- MaxThroughput int
- SendTimeout time.Duration
- Cmix cmix.CMIXParams
-}
-
-// DefaultParams returns a Params object filled with the default values.
-func DefaultParams() Params {
- return Params{
- MaxThroughput: defaultMaxThroughput,
- SendTimeout: defaultSendTimeout,
- Cmix: cmix.GetDefaultCMIXParams(),
- }
-}
-
-// GetParameters returns the default network parameters, or override with given
-// parameters, if set.
-func GetParameters(params string) (Params, error) {
- p := DefaultParams()
- if len(params) > 0 {
- err := json.Unmarshal([]byte(params), &p)
- if err != nil {
- return Params{}, err
- }
- }
- return p, nil
-}
-
-// MarshalJSON adheres to the json.Marshaler interface.
-func (p Params) MarshalJSON() ([]byte, error) {
- pDisk := paramsDisk{
- MaxThroughput: p.MaxThroughput,
- SendTimeout: p.SendTimeout,
- Cmix: p.Cmix,
- }
-
- return json.Marshal(&pDisk)
-
-}
-
-// UnmarshalJSON adheres to the json.Unmarshaler interface.
-func (p *Params) UnmarshalJSON(data []byte) error {
- pDisk := paramsDisk{}
- err := json.Unmarshal(data, &pDisk)
- if err != nil {
- return err
- }
-
- *p = Params{
- MaxThroughput: pDisk.MaxThroughput,
- SendTimeout: pDisk.SendTimeout,
- Cmix: pDisk.Cmix,
- }
-
- return nil
-}
diff --git a/fileTransfer2/params_test.go b/fileTransfer2/params_test.go
deleted file mode 100644
index 8bbeb942b4f1c5f1d70e418ebf1c5f796dd84d4a..0000000000000000000000000000000000000000
--- a/fileTransfer2/params_test.go
+++ /dev/null
@@ -1,70 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package fileTransfer2
-
-import (
- "bytes"
- "encoding/json"
- "gitlab.com/elixxir/client/cmix"
- "reflect"
- "testing"
-)
-
-// Tests that no data is lost when marshaling and
-// unmarshaling the Params object.
-func TestParams_MarshalUnmarshal(t *testing.T) {
- // Construct a set of params
- p := DefaultParams()
-
- // Marshal the params
- data, err := json.Marshal(&p)
- if err != nil {
- t.Fatalf("Marshal error: %v", err)
- }
-
- t.Logf("%s", string(data))
-
- // Unmarshal the params object
- received := Params{}
- err = json.Unmarshal(data, &received)
- if err != nil {
- t.Fatalf("Unmarshal error: %v", err)
- }
-
- // Re-marshal this params object
- data2, err := json.Marshal(received)
- if err != nil {
- t.Fatalf("Marshal error: %v", err)
- }
-
- t.Logf("%s", string(data2))
-
- // Check that they match (it is done this way to avoid
- // false failures with the reflect.DeepEqual function and
- // pointers)
- if !bytes.Equal(data, data2) {
- t.Fatalf("Data was lost in marshal/unmarshal.")
- }
-
-}
-
-// Tests that DefaultParams returns a Params object with the expected defaults.
-func TestDefaultParams(t *testing.T) {
- expected := Params{
- MaxThroughput: defaultMaxThroughput,
- SendTimeout: defaultSendTimeout,
- Cmix: cmix.GetDefaultCMIXParams(),
- }
- received := DefaultParams()
- received.Cmix.Stop = expected.Cmix.Stop
-
- if !reflect.DeepEqual(expected, received) {
- t.Errorf("Received Params does not match expected."+
- "\nexpected: %+v\nreceived: %+v", expected, received)
- }
-}
diff --git a/fileTransfer2/partTracker.go b/fileTransfer2/partTracker.go
deleted file mode 100644
index 56fc926428040e12b0bedcd8589b0dfb5c7cbb25..0000000000000000000000000000000000000000
--- a/fileTransfer2/partTracker.go
+++ /dev/null
@@ -1,68 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package fileTransfer2
-
-import (
- "gitlab.com/elixxir/client/storage/utility"
-)
-
-// sentFilePartTracker contains utility.StateVector that tracks which parts have
-// arrived. It adheres to the FilePartTracker interface.
-type sentFilePartTracker struct {
- *utility.StateVector
-}
-
-// GetPartStatus returns the status of the sent file part with the given part
-// number.
-func (s *sentFilePartTracker) GetPartStatus(partNum uint16) FpStatus {
- if uint32(partNum) >= s.GetNumKeys() {
- return -1
- }
-
- switch s.Used(uint32(partNum)) {
- case true:
- return FpArrived
- case false:
- return FpUnsent
- default:
- return -1
- }
-}
-
-// GetNumParts returns the total number of file parts in the transfer.
-func (s *sentFilePartTracker) GetNumParts() uint16 {
- return uint16(s.GetNumKeys())
-}
-
-// receivedFilePartTracker contains utility.StateVector that tracks which parts
-// have been received. It adheres to the FilePartTracker interface.
-type receivedFilePartTracker struct {
- *utility.StateVector
-}
-
-// GetPartStatus returns the status of the received file part with the given
-// part number.
-func (r *receivedFilePartTracker) GetPartStatus(partNum uint16) FpStatus {
- if uint32(partNum) >= r.GetNumKeys() {
- return -1
- }
-
- switch r.Used(uint32(partNum)) {
- case true:
- return FpReceived
- case false:
- return FpUnsent
- default:
- return -1
- }
-}
-
-// GetNumParts returns the total number of file parts in the transfer.
-func (r *receivedFilePartTracker) GetNumParts() uint16 {
- return uint16(r.GetNumKeys())
-}
diff --git a/fileTransfer2/processor.go b/fileTransfer2/processor.go
deleted file mode 100644
index 55f2021115ac7a45f4b5b08286dffc7a1ebaeabe..0000000000000000000000000000000000000000
--- a/fileTransfer2/processor.go
+++ /dev/null
@@ -1,70 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package fileTransfer2
-
-import (
- "fmt"
-
- jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/client/cmix/identity/receptionID"
- "gitlab.com/elixxir/client/cmix/rounds"
- "gitlab.com/elixxir/client/fileTransfer2/store"
- "gitlab.com/elixxir/client/fileTransfer2/store/cypher"
- "gitlab.com/elixxir/client/fileTransfer2/store/fileMessage"
- "gitlab.com/elixxir/primitives/format"
-)
-
-// Error messages.
-const (
- // processor.Process
- errDecryptPart = "[FT] Failed to decrypt file part for transfer %s (%q) on round %d: %+v"
- errUnmarshalPart = "[FT] Failed to unmarshal decrypted file part for transfer %s (%q) on round %d: %+v"
- errAddPart = "[FT] Failed to add part #%d to transfer transfer %s (%q): %+v"
-)
-
-// processor manages the reception of file transfer messages. Adheres to the
-// message.Processor interface.
-type processor struct {
- cypher.Cypher
- *store.ReceivedTransfer
- *manager
-}
-
-// Process decrypts and hands off the file part message and adds it to the
-// correct file transfer.
-func (p *processor) Process(msg format.Message,
- _ receptionID.EphemeralIdentity, round rounds.Round) {
-
- decryptedPart, err := p.Decrypt(msg)
- if err != nil {
- jww.ERROR.Printf(
- errDecryptPart, p.TransferID(), p.FileName(), round.ID, err)
- return
- }
-
- partMsg, err := fileMessage.UnmarshalPartMessage(decryptedPart)
- if err != nil {
- jww.ERROR.Printf(
- errUnmarshalPart, p.TransferID(), p.FileName(), round.ID, err)
- return
- }
-
- err = p.AddPart(partMsg.GetPart(), int(partMsg.GetPartNum()))
- if err != nil {
- jww.WARN.Printf(
- errAddPart, partMsg.GetPartNum(), p.TransferID(), p.FileName(), err)
- return
- }
-
- // Call callback with updates
- p.callbacks.Call(p.TransferID(), nil)
-}
-
-func (p *processor) String() string {
- return fmt.Sprintf("FileTransfer(%s)", p.myID)
-}
diff --git a/fileTransfer2/send.go b/fileTransfer2/send.go
deleted file mode 100644
index 1d06dcc80ea2815f1434fbeef61f37dfa64f2938..0000000000000000000000000000000000000000
--- a/fileTransfer2/send.go
+++ /dev/null
@@ -1,187 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package fileTransfer2
-
-import (
- "github.com/pkg/errors"
- jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/client/cmix"
- "gitlab.com/elixxir/client/cmix/message"
- "gitlab.com/elixxir/client/fileTransfer2/sentRoundTracker"
- "gitlab.com/elixxir/client/fileTransfer2/store"
- "gitlab.com/elixxir/client/stoppable"
- ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
- "gitlab.com/xx_network/primitives/id"
- "strconv"
- "time"
-)
-
-// Error messages.
-const (
- // generateRandomPacketSize
- getRandomNumPartsRandPanic = "[FT] Failed to generate random number of file parts to send: %+v"
-
- // manager.sendCmix
- errNoMoreRetries = "file transfer failed: ran our of retries."
-)
-
-const (
- // Duration to wait for round to finish before timing out.
- roundResultsTimeout = 15 * time.Second
-
- // Age when rounds that files were sent from are deleted from the tracker.
- clearSentRoundsAge = 10 * time.Second
-
- // Number of concurrent sending threads
- workerPoolThreads = 4
-
- // Tag that prints with cMix sending logs.
- cMixDebugTag = "FT.Part"
-
- // Prefix used for the name of a stoppable used for a sending thread
- sendThreadStoppableName = "FilePartSendingThread#"
-)
-
-// startSendingWorkerPool initialises a worker pool of file part sending
-// threads.
-func (m *manager) startSendingWorkerPool(multiStop *stoppable.Multi) {
- // Set up cMix sending parameters
- m.params.Cmix.SendTimeout = m.params.SendTimeout
- m.params.Cmix.ExcludedRounds =
- sentRoundTracker.NewManager(clearSentRoundsAge)
-
- if m.params.Cmix.DebugTag == cmix.DefaultDebugTag ||
- m.params.Cmix.DebugTag == "" {
- m.params.Cmix.DebugTag = cMixDebugTag
- }
-
- for i := 0; i < workerPoolThreads; i++ {
- stop := stoppable.NewSingle(sendThreadStoppableName + strconv.Itoa(i))
- multiStop.Add(stop)
- go m.sendingThread(stop)
- }
-}
-
-// sendingThread sends part packets that become available oin the send queue.
-func (m *manager) sendingThread(stop *stoppable.Single) {
- healthChan := make(chan bool, 10)
- healthChanID := m.cmix.AddHealthCallback(func(b bool) { healthChan <- b })
- for {
- select {
- case <-stop.Quit():
- jww.DEBUG.Printf("[FT] Stopping file part sending thread: " +
- "stoppable triggered.")
- m.cmix.RemoveHealthCallback(healthChanID)
- stop.ToStopped()
- return
- case healthy := <-healthChan:
- for !healthy {
- healthy = <-healthChan
- }
- case packet := <-m.sendQueue:
- m.sendCmix(packet)
- }
- }
-}
-
-// sendCmix sends the parts in the packet via Cmix.SendMany.
-func (m *manager) sendCmix(packet []store.Part) {
- // validParts will contain all parts in the original packet excluding those
- // that return an error from GetEncryptedPart
- validParts := make([]store.Part, 0, len(packet))
-
- // Encrypt each part and to a TargetedCmixMessage
- messages := make([]cmix.TargetedCmixMessage, 0, len(packet))
- for _, p := range packet {
- encryptedPart, mac, fp, err :=
- p.GetEncryptedPart(m.cmix.GetMaxMessageLength())
- if err != nil {
- jww.ERROR.Printf("[FT] File transfer %s (%q) failed: %+v",
- p.TransferID(), p.FileName(), err)
- m.callbacks.Call(p.TransferID(), errors.New(errNoMoreRetries))
- continue
- }
-
- validParts = append(validParts, p)
-
- messages = append(messages, cmix.TargetedCmixMessage{
- Recipient: p.Recipient(),
- Payload: encryptedPart,
- Fingerprint: fp,
- Service: message.Service{},
- Mac: mac,
- })
- }
-
- // Clear all old rounds from the sent rounds list
- m.params.Cmix.ExcludedRounds.(*sentRoundTracker.Manager).RemoveOldRounds()
-
- jww.DEBUG.Printf("[FT] Sending %d file parts via SendManyCMIX",
- len(messages))
-
- rid, _, err := m.cmix.SendMany(messages, m.params.Cmix)
- if err != nil {
- jww.WARN.Printf("[FT] Failed to send %d file parts via "+
- "SendManyCMIX: %+v", len(messages), err)
-
- for _, p := range validParts {
- m.batchQueue <- p
- }
- }
-
- err = m.cmix.GetRoundResults(
- roundResultsTimeout, m.roundResultsCallback(validParts), rid)
-}
-
-// roundResultsCallback generates a network.RoundEventCallback that handles
-// all parts in the packet once the round succeeds or fails.
-func (m *manager) roundResultsCallback(packet []store.Part) cmix.RoundEventCallback {
- // Group file parts by transfer
- grouped := map[ftCrypto.TransferID][]store.Part{}
- for _, p := range packet {
- if _, exists := grouped[*p.TransferID()]; exists {
- grouped[*p.TransferID()] = append(grouped[*p.TransferID()], p)
- } else {
- grouped[*p.TransferID()] = []store.Part{p}
- }
- }
-
- return func(
- allRoundsSucceeded, _ bool, rounds map[id.Round]cmix.RoundResult) {
- // Get round ID
- var rid id.Round
- for rid = range rounds {
- break
- }
-
- if allRoundsSucceeded {
- jww.DEBUG.Printf("[FT] %d file parts delivered on round %d (%v)",
- len(packet), rid, grouped)
-
- // If the round succeeded, then mark all parts as arrived and report
- // each transfer's progress on its progress callback
- for tid, parts := range grouped {
- for _, p := range parts {
- p.MarkArrived()
- }
-
- // Call the progress callback after all parts have been marked
- // so that the progress reported included all parts in the batch
- m.callbacks.Call(&tid, nil)
- }
- } else {
- jww.DEBUG.Printf("[FT] %d file parts failed on round %d (%v)",
- len(packet), rid, grouped)
-
- // If the round failed, then add each part into the send queue
- for _, p := range packet {
- m.batchQueue <- p
- }
- }
- }
-}
diff --git a/fileTransfer2/sentRoundTracker/sentRoundTracker.go b/fileTransfer2/sentRoundTracker/sentRoundTracker.go
deleted file mode 100644
index 29416fa62753623c88949cc11a667d23f5f2f709..0000000000000000000000000000000000000000
--- a/fileTransfer2/sentRoundTracker/sentRoundTracker.go
+++ /dev/null
@@ -1,92 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package sentRoundTracker
-
-import (
- "gitlab.com/xx_network/primitives/id"
- "gitlab.com/xx_network/primitives/netTime"
- "sync"
- "time"
-)
-
-// Manager keeps track of rounds that file parts were sent on and when
-// those rounds occurred. Rounds past the given age can be deleted manually.
-// Adheres to excludedRounds.ExcludedRounds.
-type Manager struct {
- rounds map[id.Round]time.Time
- age time.Duration
- mux sync.RWMutex
-}
-
-// NewManager creates a new sent round tracker Manager.
-func NewManager(interval time.Duration) *Manager {
- return &Manager{
- rounds: make(map[id.Round]time.Time),
- age: interval,
- }
-}
-
-// RemoveOldRounds removes any rounds that are older than the max round age.
-func (srt *Manager) RemoveOldRounds() {
- srt.mux.Lock()
- defer srt.mux.Unlock()
- deleteBefore := netTime.Now().Add(-srt.age)
-
- for rid, timeStamp := range srt.rounds {
- if timeStamp.Before(deleteBefore) {
- delete(srt.rounds, rid)
- }
- }
-}
-
-// Has indicates if the round ID is in the tracker.
-func (srt *Manager) Has(rid id.Round) bool {
- srt.mux.RLock()
- defer srt.mux.RUnlock()
-
- _, exists := srt.rounds[rid]
- return exists
-}
-
-// Insert adds the round to the tracker with the current time. Returns true if
-// the round was added.
-func (srt *Manager) Insert(rid id.Round) bool {
- timeNow := netTime.Now()
- srt.mux.Lock()
- defer srt.mux.Unlock()
-
- _, exists := srt.rounds[rid]
- if exists {
- return false
- }
-
- srt.rounds[rid] = timeNow
- return true
-}
-
-// Remove deletes a round ID from the tracker.
-func (srt *Manager) Remove(rid id.Round) {
- srt.mux.Lock()
- defer srt.mux.Unlock()
- delete(srt.rounds, rid)
-}
-
-// Len returns the number of round IDs in the tracker.
-func (srt *Manager) Len() int {
- srt.mux.RLock()
- defer srt.mux.RUnlock()
-
- return len(srt.rounds)
-}
diff --git a/fileTransfer2/sentRoundTracker/sentRoundTracker_test.go b/fileTransfer2/sentRoundTracker/sentRoundTracker_test.go
deleted file mode 100644
index f7a2fa4d74a670754e65cfbb3dca510177dc5fe6..0000000000000000000000000000000000000000
--- a/fileTransfer2/sentRoundTracker/sentRoundTracker_test.go
+++ /dev/null
@@ -1,192 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package sentRoundTracker
-
-import (
- "gitlab.com/xx_network/primitives/id"
- "reflect"
- "testing"
- "time"
-)
-
-// Tests that NewManager returns the expected new Manager.
-func Test_NewSentRoundTracker(t *testing.T) {
- interval := 10 * time.Millisecond
- expected := &Manager{
- rounds: make(map[id.Round]time.Time),
- age: interval,
- }
-
- srt := NewManager(interval)
-
- if !reflect.DeepEqual(expected, srt) {
- t.Errorf("New Manager does not match expected."+
- "\nexpected: %+v\nreceived: %+v", expected, srt)
- }
-}
-
-// Tests that Manager.RemoveOldRounds removes only old rounds and not
-// newer rounds.
-func TestManager_RemoveOldRounds(t *testing.T) {
- srt := NewManager(50 * time.Millisecond)
-
- // Add odd round to tracker
- for rid := id.Round(0); rid < 100; rid++ {
- if rid%2 != 0 {
- srt.Insert(rid)
- }
- }
-
- time.Sleep(50 * time.Millisecond)
-
- // Add even round to tracker
- for rid := id.Round(0); rid < 100; rid++ {
- if rid%2 == 0 {
- srt.Insert(rid)
- }
- }
-
- // Remove all old rounds (should be all odd rounds)
- srt.RemoveOldRounds()
-
- // Check that only even rounds exist
- for rid := id.Round(0); rid < 100; rid++ {
- if srt.Has(rid) {
- if rid%2 != 0 {
- t.Errorf("Round %d exists.", rid)
- }
- } else if rid%2 == 0 {
- t.Errorf("Round %d does not exist.", rid)
- }
- }
-}
-
-// Tests that Manager.Has returns true for all the even rounds and
-// false for all odd rounds.
-func TestManager_Has(t *testing.T) {
- srt := NewManager(0)
-
- // Insert even rounds into the tracker
- for rid := id.Round(0); rid < 100; rid++ {
- if rid%2 == 0 {
- srt.Insert(rid)
- }
- }
-
- // Check that only even rounds exist
- for rid := id.Round(0); rid < 100; rid++ {
- if srt.Has(rid) {
- if rid%2 != 0 {
- t.Errorf("Round %d exists.", rid)
- }
- } else if rid%2 == 0 {
- t.Errorf("Round %d does not exist.", rid)
- }
- }
-}
-
-// Tests that Manager.Insert adds all the expected rounds to the map and that it
-// returns true when the round does not already exist and false otherwise.
-func TestManager_Insert(t *testing.T) {
- srt := NewManager(0)
-
- // Insert even rounds into the tracker
- for rid := id.Round(0); rid < 100; rid++ {
- if rid%2 == 0 {
- if !srt.Insert(rid) {
- t.Errorf("Did not insert round %d.", rid)
- }
- }
- }
-
- // Check that only even rounds were added
- for rid := id.Round(0); rid < 100; rid++ {
- _, exists := srt.rounds[rid]
- if exists {
- if rid%2 != 0 {
- t.Errorf("Round %d exists.", rid)
- }
- } else if rid%2 == 0 {
- t.Errorf("Round %d does not exist.", rid)
- }
- }
-
- // Check that adding a round that already exists returns false
- if srt.Insert(0) {
- t.Errorf("Inserted round %d.", 0)
- }
-}
-
-// Tests that Manager.Remove removes all even rounds.
-func TestManager_Remove(t *testing.T) {
- srt := NewManager(0)
-
- // Add all round to tracker
- for rid := id.Round(0); rid < 100; rid++ {
- srt.Insert(rid)
- }
-
- // Remove even rounds from the tracker
- for rid := id.Round(0); rid < 100; rid++ {
- if rid%2 == 0 {
- srt.Remove(rid)
- }
- }
-
- // Check that only even rounds were removed
- for rid := id.Round(0); rid < 100; rid++ {
- _, exists := srt.rounds[rid]
- if exists {
- if rid%2 == 0 {
- t.Errorf("Round %d does not exist.", rid)
- }
- } else if rid%2 != 0 {
- t.Errorf("Round %d exists.", rid)
- }
- }
-}
-
-// Tests that Manager.Len returns the expected length when the tracker
-// is empty, filled, and then modified.
-func TestManager_Len(t *testing.T) {
- srt := NewManager(0)
-
- if srt.Len() != 0 {
- t.Errorf("Length of tracker incorrect.\nexpected: %d\nreceived: %d",
- 0, srt.Len())
- }
-
- // Add all round to tracker
- for rid := id.Round(0); rid < 100; rid++ {
- srt.Insert(rid)
- }
-
- if srt.Len() != 100 {
- t.Errorf("Length of tracker incorrect.\nexpected: %d\nreceived: %d",
- 100, srt.Len())
- }
-
- // Remove even rounds from the tracker
- for rid := id.Round(0); rid < 100; rid++ {
- if rid%2 == 0 {
- srt.Remove(rid)
- }
- }
-
- if srt.Len() != 50 {
- t.Errorf("Length of tracker incorrect.\nexpected: %d\nreceived: %d",
- 50, srt.Len())
- }
-}
diff --git a/fileTransfer2/store/cypher/cypher.go b/fileTransfer2/store/cypher/cypher.go
deleted file mode 100644
index 0c05751cac11717518a4751868fba321822946b5..0000000000000000000000000000000000000000
--- a/fileTransfer2/store/cypher/cypher.go
+++ /dev/null
@@ -1,59 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package cypher
-
-import (
- ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
- "gitlab.com/elixxir/primitives/format"
-)
-
-// Cypher contains the cryptographic and identifying information needed to
-// decrypt a file part and associate it with the correct file.
-type Cypher struct {
- *Manager
- fpNum uint16
-}
-
-// Encrypt encrypts the file part contents and returns them along with a MAC and
-// fingerprint.
-func (c Cypher) Encrypt(contents []byte) (
- cipherText, mac []byte, fp format.Fingerprint) {
-
- // Generate fingerprint
- fp = ftCrypto.GenerateFingerprint(*c.key, c.fpNum)
-
- // Encrypt part and get MAC
- cipherText, mac = ftCrypto.EncryptPart(*c.key, contents, c.fpNum, fp)
-
- return cipherText, mac, fp
-}
-
-// Decrypt decrypts the content of the message.
-func (c Cypher) Decrypt(msg format.Message) ([]byte, error) {
- filePart, err := ftCrypto.DecryptPart(
- *c.key, msg.GetContents(), msg.GetMac(), c.fpNum, msg.GetKeyFP())
- if err != nil {
- return nil, err
- }
-
- c.fpVector.Use(uint32(c.fpNum))
-
- return filePart, nil
-}
-
-// GetFingerprint generates and returns the fingerprints.
-func (c Cypher) GetFingerprint() format.Fingerprint {
- return ftCrypto.GenerateFingerprint(*c.key, c.fpNum)
-}
diff --git a/fileTransfer2/store/cypher/cypher_test.go b/fileTransfer2/store/cypher/cypher_test.go
deleted file mode 100644
index 7fea485da2f35952ccdfea586aaa3aa7e5ab6d82..0000000000000000000000000000000000000000
--- a/fileTransfer2/store/cypher/cypher_test.go
+++ /dev/null
@@ -1,104 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package cypher
-
-import (
- "bytes"
- "gitlab.com/elixxir/primitives/format"
- "testing"
-)
-
-// Tests that contents that are encrypted with Cypher.Encrypt match the
-// decrypted contents of Cypher.Decrypt.
-func TestCypher_Encrypt_Decrypt(t *testing.T) {
- m, _ := newTestManager(16, t)
- numPrimeBytes := 512
-
- // Create contents of the right size
- contents := make([]byte, format.NewMessage(numPrimeBytes).ContentsSize())
- copy(contents, "This is some message contents.")
-
- c, err := m.PopCypher()
- if err != nil {
- t.Errorf("Failed to pop cypher: %+v", err)
- }
-
- // Encrypt contents
- cipherText, mac, fp := c.Encrypt(contents)
-
- // Create message to decrypt
- msg := format.NewMessage(numPrimeBytes)
- msg.SetContents(cipherText)
- msg.SetMac(mac)
- msg.SetKeyFP(fp)
-
- // Decrypt message
- decryptedContents, err := c.Decrypt(msg)
- if err != nil {
- t.Errorf("Decrypt returned an error: %+v", err)
- }
-
- // Tests that the decrypted contents match the original
- if !bytes.Equal(contents, decryptedContents) {
- t.Errorf("Decrypted contents do not match original."+
- "\nexpected: %q\nreceived: %q", contents, decryptedContents)
- }
-}
-
-// Tests that Cypher.Decrypt returns an error when the contents are the wrong
-// size.
-func TestCypher_Decrypt_MacError(t *testing.T) {
- m, _ := newTestManager(16, t)
-
- // Create contents of the wrong size
- contents := []byte("This is some message contents.")
-
- c, err := m.PopCypher()
- if err != nil {
- t.Errorf("Failed to pop cypher: %+v", err)
- }
-
- // Encrypt contents
- cipherText, mac, fp := c.Encrypt(contents)
-
- // Create message to decrypt
- msg := format.NewMessage(512)
- msg.SetContents(cipherText)
- msg.SetMac(mac)
- msg.SetKeyFP(fp)
-
- // Decrypt message
- _, err = c.Decrypt(msg)
- if err == nil {
- t.Error("Failed to receive an error when the contents are the wrong " +
- "length.")
- }
-}
-
-// Tests that Cypher.GetFingerprint returns unique fingerprints.
-func TestCypher_GetFingerprint(t *testing.T) {
- m, _ := newTestManager(16, t)
- fpMap := make(map[format.Fingerprint]bool, m.fpVector.GetNumKeys())
-
- for c, err := m.PopCypher(); err == nil; c, err = m.PopCypher() {
- fp := c.GetFingerprint()
-
- if fpMap[fp] {
- t.Errorf("Fingerprint %s already exists.", fp)
- } else {
- fpMap[fp] = true
- }
- }
-}
diff --git a/fileTransfer2/store/cypher/manager.go b/fileTransfer2/store/cypher/manager.go
deleted file mode 100644
index f66100d4c27a608133f81424a32351fc1ba8bb58..0000000000000000000000000000000000000000
--- a/fileTransfer2/store/cypher/manager.go
+++ /dev/null
@@ -1,186 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package cypher
-
-import (
- "github.com/pkg/errors"
- "gitlab.com/elixxir/client/storage/utility"
- "gitlab.com/elixxir/client/storage/versioned"
- ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
- "gitlab.com/xx_network/primitives/netTime"
-)
-
-// Storage keys and versions.
-const (
- cypherManagerPrefix = "CypherManagerStore"
- cypherManagerFpVectorKey = "CypherManagerFingerprintVector"
- cypherManagerKeyStoreKey = "CypherManagerKey"
- cypherManagerKeyStoreVersion = 0
-)
-
-// Error messages.
-const (
- // NewManager
- errNewFpVector = "failed to create new state vector for fingerprints: %+v"
- errSaveKey = "failed to save transfer key: %+v"
-
- // LoadManager
- errLoadKey = "failed to load transfer key: %+v"
- errLoadFpVector = "failed to load state vector: %+v"
-
- // Manager.PopCypher
- errGetNextFp = "used all %d fingerprints"
-
- // Manager.Delete
- errDeleteKey = "failed to delete transfer key: %+v"
- errDeleteFpVector = "failed to delete fingerprint state vector: %+v"
-)
-
-// Manager the creation
-type Manager struct {
- // The transfer key is a randomly generated key created by the sender and
- // used to generate MACs and fingerprints
- key *ftCrypto.TransferKey
-
- // Stores the state of a fingerprint (used/unused) in a bitstream format
- // (has its own storage backend)
- fpVector *utility.StateVector
-
- kv *versioned.KV
-}
-
-// NewManager returns a new cypher Manager initialised with the given number of
-// fingerprints.
-func NewManager(key *ftCrypto.TransferKey, numFps uint16, kv *versioned.KV) (
- *Manager, error) {
-
- kv = kv.Prefix(cypherManagerPrefix)
-
- fpVector, err := utility.NewStateVector(
- kv, cypherManagerFpVectorKey, uint32(numFps))
- if err != nil {
- return nil, errors.Errorf(errNewFpVector, err)
- }
-
- err = saveKey(key, kv)
- if err != nil {
- return nil, errors.Errorf(errSaveKey, err)
- }
-
- tfp := &Manager{
- key: key,
- fpVector: fpVector,
- kv: kv,
- }
-
- return tfp, nil
-}
-
-// PopCypher returns a new Cypher with next available fingerprint number. This
-// marks the fingerprint as used. Returns false if no more fingerprints are
-// available.
-func (m *Manager) PopCypher() (Cypher, error) {
- fpNum, err := m.fpVector.Next()
- if err != nil {
- return Cypher{}, errors.Errorf(errGetNextFp, m.fpVector.GetNumKeys())
- }
-
- c := Cypher{
- Manager: m,
- fpNum: uint16(fpNum),
- }
-
- return c, nil
-}
-
-// GetUnusedCyphers returns a list of cyphers with unused fingerprints numbers.
-func (m *Manager) GetUnusedCyphers() []Cypher {
- fpNums := m.fpVector.GetUnusedKeyNums()
- cypherList := make([]Cypher, len(fpNums))
-
- for i, fpNum := range fpNums {
- cypherList[i] = Cypher{
- Manager: m,
- fpNum: uint16(fpNum),
- }
- }
-
- return cypherList
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Storage Functions //
-////////////////////////////////////////////////////////////////////////////////
-
-// LoadManager loads the Manager from storage.
-func LoadManager(kv *versioned.KV) (*Manager, error) {
- kv = kv.Prefix(cypherManagerPrefix)
- key, err := loadKey(kv)
- if err != nil {
- return nil, errors.Errorf(errLoadKey, err)
- }
-
- fpVector, err := utility.LoadStateVector(kv, cypherManagerFpVectorKey)
- if err != nil {
- return nil, errors.Errorf(errLoadFpVector, err)
- }
-
- tfp := &Manager{
- key: key,
- fpVector: fpVector,
- kv: kv,
- }
-
- return tfp, nil
-}
-
-// Delete removes all saved entries from storage.
-func (m *Manager) Delete() error {
- // Delete transfer key
- err := m.kv.Delete(cypherManagerKeyStoreKey, cypherManagerKeyStoreVersion)
- if err != nil {
- return errors.Errorf(errDeleteKey, err)
- }
-
- // Delete StateVector
- err = m.fpVector.Delete()
- if err != nil {
- return errors.Errorf(errDeleteFpVector, err)
- }
-
- return nil
-}
-
-// saveKey saves the transfer key to storage.
-func saveKey(key *ftCrypto.TransferKey, kv *versioned.KV) error {
- obj := &versioned.Object{
- Version: cypherManagerKeyStoreVersion,
- Timestamp: netTime.Now(),
- Data: key.Bytes(),
- }
-
- return kv.Set(cypherManagerKeyStoreKey, cypherManagerKeyStoreVersion, obj)
-}
-
-// loadKey loads the transfer key from storage.
-func loadKey(kv *versioned.KV) (*ftCrypto.TransferKey, error) {
- obj, err := kv.Get(cypherManagerKeyStoreKey, cypherManagerKeyStoreVersion)
- if err != nil {
- return nil, err
- }
-
- key := ftCrypto.UnmarshalTransferKey(obj.Data)
- return &key, nil
-}
diff --git a/fileTransfer2/store/cypher/manager_test.go b/fileTransfer2/store/cypher/manager_test.go
deleted file mode 100644
index d354adcd6aed068e8c182102d7a7161060415ec9..0000000000000000000000000000000000000000
--- a/fileTransfer2/store/cypher/manager_test.go
+++ /dev/null
@@ -1,177 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package cypher
-
-import (
- "fmt"
- "gitlab.com/elixxir/client/storage/utility"
- "gitlab.com/elixxir/client/storage/versioned"
- ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
- "gitlab.com/elixxir/ekv"
- "gitlab.com/xx_network/crypto/csprng"
- "reflect"
- "testing"
-)
-
-// Tests that NewManager returns a new Manager that matches the expected
-// manager.
-func TestNewManager(t *testing.T) {
- kv := versioned.NewKV(ekv.MakeMemstore())
- numFps := uint16(64)
- fpv, _ := utility.NewStateVector(kv.Prefix(cypherManagerPrefix),
- cypherManagerFpVectorKey, uint32(numFps))
- expected := &Manager{
- key: &ftCrypto.TransferKey{1, 2, 3},
- fpVector: fpv,
- kv: kv.Prefix(cypherManagerPrefix),
- }
-
- manager, err := NewManager(expected.key, numFps, kv)
- if err != nil {
- t.Errorf("NewManager returned an error: %+v", err)
- }
-
- if !reflect.DeepEqual(expected, manager) {
- t.Errorf("New manager does not match expected."+
- "\nexpected: %+v\nreceived: %+v", expected, manager)
- }
-}
-
-// Tests that Manager.PopCypher returns cyphers with correct fingerprint numbers
-// and that trying to pop after the last pop results in an error.
-func TestManager_PopCypher(t *testing.T) {
- m, _ := newTestManager(64, t)
-
- for i := uint16(0); i < uint16(m.fpVector.GetNumKeys()); i++ {
- c, err := m.PopCypher()
- if err != nil {
- t.Errorf("Failed to pop cypher #%d: %+v", i, err)
- }
-
- if c.fpNum != i {
- t.Errorf("Fingerprint number does not match expected."+
- "\nexpected: %d\nreceived: %d", i, c.fpNum)
- }
-
- if c.Manager != m {
- t.Errorf("Cypher has wrong manager.\nexpected: %v\nreceived: %v",
- m, c.Manager)
- }
- }
-
- // Test that an error is returned when popping a cypher after all
- // fingerprints have been used
- expectedErr := fmt.Sprintf(errGetNextFp, m.fpVector.GetNumKeys())
- _, err := m.PopCypher()
- if err == nil || (err.Error() != expectedErr) {
- t.Errorf("PopCypher did not return the expected error when all "+
- "fingerprints should be used.\nexpected: %s\nreceived: %+v",
- expectedErr, err)
- }
-}
-
-// Tests Manager.GetUnusedCyphers
-func TestManager_GetUnusedCyphers(t *testing.T) {
- m, _ := newTestManager(64, t)
-
- // Use every other key
- for i := uint32(0); i < m.fpVector.GetNumKeys(); i += 2 {
- m.fpVector.Use(i)
- }
-
- // Check that every other key is in the list
- for i, c := range m.GetUnusedCyphers() {
- if c.fpNum != uint16(2*i)+1 {
- t.Errorf("Fingerprint number #%d incorrect."+
- "\nexpected: %d\nreceived: %d", i, 2*i+1, c.fpNum)
- }
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Storage Functions //
-////////////////////////////////////////////////////////////////////////////////
-
-// Tests that a Manager loaded via LoadManager matches the original.
-func TestLoadManager(t *testing.T) {
- m, kv := newTestManager(64, t)
-
- // Use every other key
- for i := uint32(0); i < m.fpVector.GetNumKeys(); i += 2 {
- m.fpVector.Use(i)
- }
-
- newManager, err := LoadManager(kv)
- if err != nil {
- t.Errorf("Failed to load manager: %+v", err)
- }
-
- if !reflect.DeepEqual(m, newManager) {
- t.Errorf("Loaded manager does not match original."+
- "\nexpected: %+v\nreceived: %+v", m, newManager)
- }
-}
-
-// Tests that Manager.Delete deletes the storage by trying to load the manager.
-func TestManager_Delete(t *testing.T) {
- m, _ := newTestManager(64, t)
-
- err := m.Delete()
- if err != nil {
- t.Errorf("Failed to delete manager: %+v", err)
- }
-
- _, err = LoadManager(m.kv)
- if err == nil {
- t.Error("Failed to receive error when loading manager that was deleted.")
- }
-}
-
-// Tests that a transfer key saved via saveKey can be loaded via loadKey.
-func Test_saveKey_loadKey(t *testing.T) {
- kv := versioned.NewKV(ekv.MakeMemstore())
- key := &ftCrypto.TransferKey{42}
-
- err := saveKey(key, kv)
- if err != nil {
- t.Errorf("Error when saving key: %+v", err)
- }
-
- loadedKey, err := loadKey(kv)
- if err != nil {
- t.Errorf("Error when loading key: %+v", err)
- }
-
- if *key != *loadedKey {
- t.Errorf("Loaded key does not match original."+
- "\nexpected: %s\nreceived: %s", key, loadedKey)
- }
-}
-
-// newTestManager creates a new Manager for testing.
-func newTestManager(numFps uint16, t *testing.T) (*Manager, *versioned.KV) {
- key, err := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
- if err != nil {
- t.Errorf("Failed to generate transfer key: %+v", err)
- }
-
- kv := versioned.NewKV(ekv.MakeMemstore())
- m, err := NewManager(&key, numFps, kv)
- if err != nil {
- t.Errorf("Failed to make new Manager: %+v", err)
- }
-
- return m, kv
-}
diff --git a/fileTransfer2/store/fileMessage/fileMessage.go b/fileTransfer2/store/fileMessage/fileMessage.go
deleted file mode 100644
index 58f3b1273de9812be5960c95eac06f649d23b0e8..0000000000000000000000000000000000000000
--- a/fileTransfer2/store/fileMessage/fileMessage.go
+++ /dev/null
@@ -1,124 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package fileMessage
-
-import (
- "encoding/binary"
- "github.com/pkg/errors"
- jww "github.com/spf13/jwalterweatherman"
-)
-
-// Size constants.
-const (
- partNumLen = 2 // The length of the part number in bytes
- fmMinSize = partNumLen // Minimum size for the PartMessage
-)
-
-// Error messages.
-const (
- errNewFmSize = "[FT] Could not create file part message: size of payload (%d) must be greater than %d"
- unmarshalFmSizeErr = "size of passed in bytes (%d) must be greater than %d"
- errSetFileFm = "[FT] Could not set file part message payload: length of part bytes (%d) must be smaller than maximum payload size %d"
-)
-
-/*
-+-------------------------------+
-| CMIX Message Contents |
-+-------------+-----------------+
-| Part Number | File Data |
-| 2 bytes | remaining space |
-+-------------+-----------------+
-*/
-
-// PartMessage contains part of the data being transferred and 256-bit nonce
-// that is used as a nonce.
-type PartMessage struct {
- data []byte // Serial of all contents
- partNum []byte // The part number of the file
- part []byte // File part data
-}
-
-// NewPartMessage generates a new part message that fits into the specified
-// external payload size. An error is returned if the external payload size is
-// too small to fit the part message.
-func NewPartMessage(externalPayloadSize int) PartMessage {
- if externalPayloadSize < fmMinSize {
- jww.FATAL.Panicf(errNewFmSize, externalPayloadSize, fmMinSize)
- }
-
- return mapPartMessage(make([]byte, externalPayloadSize))
-}
-
-// mapPartMessage maps the data to the components of a PartMessage. It is mapped
-// by reference; a copy is not made.
-func mapPartMessage(data []byte) PartMessage {
- return PartMessage{
- data: data,
- partNum: data[:partNumLen],
- part: data[partNumLen:],
- }
-}
-
-// UnmarshalPartMessage converts the bytes into a PartMessage. An error is
-// returned if the size of the data is too small for a PartMessage.
-func UnmarshalPartMessage(b []byte) (PartMessage, error) {
- if len(b) < fmMinSize {
- return PartMessage{},
- errors.Errorf(unmarshalFmSizeErr, len(b), fmMinSize)
- }
-
- return mapPartMessage(b), nil
-}
-
-// Marshal returns the byte representation of the PartMessage.
-func (m PartMessage) Marshal() []byte {
- b := make([]byte, len(m.data))
- copy(b, m.data)
- return b
-}
-
-// GetPartNum returns the file part number.
-func (m PartMessage) GetPartNum() uint16 {
- return binary.LittleEndian.Uint16(m.partNum)
-}
-
-// SetPartNum sets the file part number.
-func (m PartMessage) SetPartNum(num uint16) {
- b := make([]byte, partNumLen)
- binary.LittleEndian.PutUint16(b, num)
- copy(m.partNum, b)
-}
-
-// GetPart returns the file part data from the message.
-func (m PartMessage) GetPart() []byte {
- b := make([]byte, len(m.part))
- copy(b, m.part)
- return b
-}
-
-// SetPart sets the PartMessage part to the given bytes. An error is returned if
-// the size of the provided part data is too large to store.
-func (m PartMessage) SetPart(b []byte) {
- if len(b) > len(m.part) {
- jww.FATAL.Panicf(errSetFileFm, len(b), len(m.part))
- }
-
- copy(m.part, b)
-}
-
-// GetPartSize returns the number of bytes available to store part data.
-func (m PartMessage) GetPartSize() int {
- return len(m.part)
-}
diff --git a/fileTransfer2/store/fileMessage/fileMessage_test.go b/fileTransfer2/store/fileMessage/fileMessage_test.go
deleted file mode 100644
index f7e169456e1d9dee3121e7a653b9b109417036a9..0000000000000000000000000000000000000000
--- a/fileTransfer2/store/fileMessage/fileMessage_test.go
+++ /dev/null
@@ -1,236 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package fileMessage
-
-import (
- "bytes"
- "encoding/binary"
- "fmt"
- "math/rand"
- "testing"
-)
-
-// Tests that NewPartMessage returns a PartMessage of the expected size.
-func Test_newPartMessage(t *testing.T) {
- externalPayloadSize := 256
-
- fm := NewPartMessage(externalPayloadSize)
-
- if len(fm.data) != externalPayloadSize {
- t.Errorf("Size of PartMessage data does not match payload size."+
- "\nexpected: %d\nreceived: %d", externalPayloadSize, len(fm.data))
- }
-}
-
-// Error path: tests that NewPartMessage returns the expected error when the
-// external payload size is too small.
-func Test_newPartMessage_SmallPayloadSizeError(t *testing.T) {
- externalPayloadSize := fmMinSize - 1
- expectedErr := fmt.Sprintf(errNewFmSize, externalPayloadSize, fmMinSize)
-
- defer func() {
- if r := recover(); r == nil || r != expectedErr {
- t.Errorf("NewPartMessage did not return the expected error when "+
- "the given external payload size is too small."+
- "\nexpected: %s\nreceived: %+v", expectedErr, r)
- }
- }()
-
- NewPartMessage(externalPayloadSize)
-}
-
-// Tests that mapPartMessage maps the data to the correct parts of the
-// PartMessage.
-func Test_mapPartMessage(t *testing.T) {
- // Generate expected values
- _, expectedData, expectedPartNum, expectedFile :=
- newRandomFileMessage()
-
- fm := mapPartMessage(expectedData)
-
- if !bytes.Equal(expectedData, fm.data) {
- t.Errorf("Incorrect data.\nexpected: %q\nreceived: %q",
- expectedData, fm.data)
- }
-
- if !bytes.Equal(expectedPartNum, fm.partNum) {
- t.Errorf("Incorrect part number.\nexpected: %q\nreceived: %q",
- expectedPartNum, fm.partNum)
- }
-
- if !bytes.Equal(expectedFile, fm.part) {
- t.Errorf("Incorrect part data.\nexpected: %q\nreceived: %q",
- expectedFile, fm.part)
- }
-
-}
-
-// Tests that UnmarshalPartMessage returns a PartMessage with the expected
-// values.
-func Test_unmarshalPartMessage(t *testing.T) {
- // Generate expected values
- _, expectedData, expectedPartNumb, expectedFile :=
- newRandomFileMessage()
-
- fm, err := UnmarshalPartMessage(expectedData)
- if err != nil {
- t.Errorf("UnmarshalPartMessage return an error: %+v", err)
- }
-
- if !bytes.Equal(expectedData, fm.data) {
- t.Errorf("Incorrect data.\nexpected: %q\nreceived: %q",
- expectedData, fm.data)
- }
-
- if !bytes.Equal(expectedPartNumb, fm.partNum) {
- t.Errorf("Incorrect part number.\nexpected: %q\nreceived: %q",
- expectedPartNumb, fm.partNum)
- }
-
- if !bytes.Equal(expectedFile, fm.part) {
- t.Errorf("Incorrect part data.\nexpected: %q\nreceived: %q",
- expectedFile, fm.part)
- }
-}
-
-// Error path: tests that UnmarshalPartMessage returns the expected error when
-// the provided data is too small to be unmarshalled into a PartMessage.
-func Test_unmarshalPartMessage_SizeError(t *testing.T) {
- data := make([]byte, fmMinSize-1)
- expectedErr := fmt.Sprintf(unmarshalFmSizeErr, len(data), fmMinSize)
-
- _, err := UnmarshalPartMessage(data)
- if err == nil || err.Error() != expectedErr {
- t.Errorf("UnmarshalPartMessage did not return the expected error when "+
- "the given bytes are too small to be a PartMessage."+
- "\nexpected: %s\nreceived: %+v", expectedErr, err)
- }
-}
-
-// Tests that PartMessage.Marshal returns the correct data.
-func Test_fileMessage_marshal(t *testing.T) {
- fm, expectedData, _, _ := newRandomFileMessage()
-
- data := fm.Marshal()
-
- if !bytes.Equal(expectedData, data) {
- t.Errorf("Marshalled data does not match expected."+
- "\nexpected: %q\nreceived: %q", expectedData, data)
- }
-}
-
-// Tests that PartMessage.GetPartNum returns the correct part number.
-func Test_fileMessage_getPartNum(t *testing.T) {
- fm, _, expectedPartNum, _ := newRandomFileMessage()
-
- partNum := fm.GetPartNum()
- expected := binary.LittleEndian.Uint16(expectedPartNum)
-
- if expected != partNum {
- t.Errorf("Part number does not match expected."+
- "\nexpected: %d\nreceived: %d", expected, partNum)
- }
-}
-
-// Tests that PartMessage.SetPartNum sets the correct part number.
-func Test_fileMessage_setPartNum(t *testing.T) {
- fm := NewPartMessage(256)
-
- expectedPartNum := make([]byte, partNumLen)
- rand.New(rand.NewSource(42)).Read(expectedPartNum)
- expected := binary.LittleEndian.Uint16(expectedPartNum)
-
- fm.SetPartNum(expected)
-
- if expected != fm.GetPartNum() {
- t.Errorf("Failed to set correct part number.\nexpected: %d\nreceived: %d",
- expected, fm.GetPartNum())
- }
-}
-
-// Tests that PartMessage.GetPart returns the correct part data.
-func Test_fileMessage_getFile(t *testing.T) {
- fm, _, _, expectedFile := newRandomFileMessage()
-
- file := fm.GetPart()
-
- if !bytes.Equal(expectedFile, file) {
- t.Errorf("File data does not match expected."+
- "\nexpected: %q\nreceived: %q", expectedFile, file)
- }
-}
-
-// Tests that PartMessage.SetPart sets the correct part data.
-func Test_fileMessage_setFile(t *testing.T) {
- fm := NewPartMessage(256)
-
- fileData := make([]byte, 64)
- rand.New(rand.NewSource(42)).Read(fileData)
- expectedFile := make([]byte, fm.GetPartSize())
- copy(expectedFile, fileData)
-
- fm.SetPart(expectedFile)
-
- if !bytes.Equal(expectedFile, fm.GetPart()) {
- t.Errorf("Failed to set correct part data.\nexpected: %q\nreceived: %q",
- expectedFile, fm.GetPart())
- }
-}
-
-// Error path: tests that PartMessage.SetPart returns the expected error when
-// the provided part data is too large for the message.
-func Test_fileMessage_setFile_FileTooLargeError(t *testing.T) {
- fm := NewPartMessage(fmMinSize + 1)
-
- expectedErr := fmt.Sprintf(errSetFileFm, fm.GetPartSize()+1, fm.GetPartSize())
-
- defer func() {
- if r := recover(); r == nil || r != expectedErr {
- t.Errorf("SetPart did not return the expected error when the "+
- "given part data is too large to fit in the PartMessage."+
- "\nexpected: %s\nreceived: %+v", expectedErr, r)
- }
- }()
-
- fm.SetPart(make([]byte, fm.GetPartSize()+1))
-}
-
-// Tests that PartMessage.GetPartSize returns the expected available space for
-// the part data.
-func Test_fileMessage_getFileSize(t *testing.T) {
- expectedSize := 256
-
- fm := NewPartMessage(fmMinSize + expectedSize)
-
- if expectedSize != fm.GetPartSize() {
- t.Errorf("File size incorrect.\nexpected: %d\nreceived: %d",
- expectedSize, fm.GetPartSize())
- }
-}
-
-// newRandomFileMessage generates a new PartMessage filled with random data and
-// return the PartMessage and its individual parts.
-func newRandomFileMessage() (PartMessage, []byte, []byte, []byte) {
- prng := rand.New(rand.NewSource(42))
- partNum := make([]byte, partNumLen)
- prng.Read(partNum)
- part := make([]byte, 64)
- prng.Read(part)
- data := append(partNum, part...)
-
- fm := mapPartMessage(data)
-
- return fm, data, partNum, part
-}
diff --git a/fileTransfer2/store/part.go b/fileTransfer2/store/part.go
deleted file mode 100644
index 9229cfb008a8da189a7fd00d401cae8a31ed3c5a..0000000000000000000000000000000000000000
--- a/fileTransfer2/store/part.go
+++ /dev/null
@@ -1,70 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package store
-
-import (
- "gitlab.com/elixxir/client/fileTransfer2/store/cypher"
- "gitlab.com/elixxir/client/fileTransfer2/store/fileMessage"
- ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
- "gitlab.com/elixxir/primitives/format"
- "gitlab.com/xx_network/primitives/id"
-)
-
-// Part contains information about a single file part and its parent transfer.
-// Also contains cryptographic information needed to encrypt the part data.
-type Part struct {
- transfer *SentTransfer
- cypherManager *cypher.Manager
- partNum uint16
-}
-
-// GetEncryptedPart gets the specified part, encrypts it, and returns the
-// encrypted part along with its MAC and fingerprint. An error is returned if no
-// fingerprints are available.
-func (p *Part) GetEncryptedPart(contentsSize int) (
- encryptedPart, mac []byte, fp format.Fingerprint, err error) {
- // Create new empty file part message of the size provided
- partMsg := fileMessage.NewPartMessage(contentsSize)
-
- // Add part number and part data to part message
- partMsg.SetPartNum(p.partNum)
- partMsg.SetPart(p.transfer.getPartData(p.partNum))
-
- // Get next cypher
- c, err := p.cypherManager.PopCypher()
- if err != nil {
- p.transfer.markTransferFailed()
- return nil, nil, format.Fingerprint{}, err
- }
-
- // Encrypt part and get MAC and fingerprint
- encryptedPart, mac, fp = c.Encrypt(partMsg.Marshal())
-
- return encryptedPart, mac, fp, nil
-}
-
-// MarkArrived marks the part as arrived. This should be called after the round
-// the part is sent on succeeds.
-func (p *Part) MarkArrived() {
- p.transfer.markArrived(p.partNum)
-}
-
-// Recipient returns the recipient of the file transfer.
-func (p *Part) Recipient() *id.ID {
- return p.transfer.recipient
-}
-
-// TransferID returns the ID of the file transfer.
-func (p *Part) TransferID() *ftCrypto.TransferID {
- return p.transfer.tid
-}
-
-// FileName returns the name of the file.
-func (p *Part) FileName() string {
- return p.transfer.FileName()
-}
diff --git a/fileTransfer2/store/part_test.go b/fileTransfer2/store/part_test.go
deleted file mode 100644
index 67748160971e47c378c7c5fb31fb188014244fb7..0000000000000000000000000000000000000000
--- a/fileTransfer2/store/part_test.go
+++ /dev/null
@@ -1,126 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package store
-
-import (
- "bytes"
- "gitlab.com/elixxir/client/fileTransfer2/store/fileMessage"
- ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
- "gitlab.com/elixxir/primitives/format"
- "testing"
-)
-
-// Tests that the encrypted part returned by Part.GetEncryptedPart can be
-// decrypted, unmarshalled, and that it matches the original.
-func TestPart_GetEncryptedPart(t *testing.T) {
- st, parts, key, _, _ := newTestSentTransfer(25, t)
- partNum := 0
- part := st.GetUnsentParts()[partNum]
-
- encryptedPart, mac, fp, err := part.GetEncryptedPart(
- format.NewMessage(numPrimeBytes).ContentsSize())
- if err != nil {
- t.Errorf("GetEncryptedPart returned an error: %+v", err)
- }
-
- decryptedPart, err := ftCrypto.DecryptPart(
- *key, encryptedPart, mac, uint16(partNum), fp)
- if err != nil {
- t.Errorf("Failed to decrypt part: %+v", err)
- }
-
- partMsg, err := fileMessage.UnmarshalPartMessage(decryptedPart)
- if err != nil {
- t.Errorf("Failed to unmarshal part message: %+v", err)
- }
-
- if !bytes.Equal(parts[partNum], partMsg.GetPart()) {
- t.Errorf("Decrypted part does not match original."+
- "\nexpected: %q\nreceived: %q", parts[partNum], partMsg.GetPart())
- }
-
- if int(partMsg.GetPartNum()) != partNum {
- t.Errorf("Decrypted part does not have correct part number."+
- "\nexpected: %d\nreceived: %d", partNum, partMsg.GetPartNum())
- }
-}
-
-// Tests that Part.GetEncryptedPart returns an error when the underlying cypher
-// manager runs out of fingerprints.
-func TestPart_GetEncryptedPart_OutOfFingerprints(t *testing.T) {
- numParts := uint16(25)
- st, _, _, numFps, _ := newTestSentTransfer(numParts, t)
- part := st.GetUnsentParts()[0]
- for i := uint16(0); i < numFps; i++ {
- _, _, _, err := part.GetEncryptedPart(
- format.NewMessage(numPrimeBytes).ContentsSize())
- if err != nil {
- t.Errorf("Getting encrtypted part %d failed: %+v", i, err)
- }
- }
-
- _, _, _, err := part.GetEncryptedPart(
- format.NewMessage(numPrimeBytes).ContentsSize())
- if err == nil {
- t.Errorf("Failed to get an error when run out of fingerprints.")
- }
-}
-
-// Tests that Part.MarkArrived correctly marks the part's status in the
-// SentTransfer's partStatus vector.
-func TestPart_MarkArrived(t *testing.T) {
- st, _, _, _, _ := newTestSentTransfer(25, t)
- partNum := 0
- part := st.GetUnsentParts()[partNum]
-
- part.MarkArrived()
-
- if !st.partStatus.Used(uint32(partNum)) {
- t.Errorf("Part #%d not marked as arrived.", partNum)
- }
-}
-
-// Tests that Part.Recipient returns the correct recipient ID.
-func TestPart_Recipient(t *testing.T) {
- st, _, _, _, _ := newTestSentTransfer(25, t)
- part := st.GetUnsentParts()[0]
-
- if !part.Recipient().Cmp(st.Recipient()) {
- t.Errorf("Recipient ID does not match expected."+
- "\nexpected: %s\nreceived: %s", st.Recipient(), part.Recipient())
- }
-}
-
-// Tests that Part.TransferID returns the correct transfer ID.
-func TestPart_TransferID(t *testing.T) {
- st, _, _, _, _ := newTestSentTransfer(25, t)
- part := st.GetUnsentParts()[0]
-
- if part.TransferID() != st.TransferID() {
- t.Errorf("Transfer ID does not match expected."+
- "\nexpected: %s\nreceived: %s", st.TransferID(), part.TransferID())
- }
-}
-
-// Tests that Part.FileName returns the correct file name.
-func TestPart_FileName(t *testing.T) {
- st, _, _, _, _ := newTestSentTransfer(25, t)
- part := st.GetUnsentParts()[0]
-
- if part.FileName() != st.FileName() {
- t.Errorf("File name does not match expected."+
- "\nexpected: %q\nreceived: %q", st.FileName(), part.FileName())
- }
-}
diff --git a/fileTransfer2/store/received.go b/fileTransfer2/store/received.go
deleted file mode 100644
index 921ced2f624959cdbab4d345e92719f0d76c9ad5..0000000000000000000000000000000000000000
--- a/fileTransfer2/store/received.go
+++ /dev/null
@@ -1,181 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package store
-
-import (
- "encoding/json"
- "github.com/pkg/errors"
- jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/client/storage/versioned"
- ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
- "gitlab.com/elixxir/ekv"
- "gitlab.com/xx_network/primitives/netTime"
- "sync"
-)
-
-// Storage keys and versions.
-const (
- receivedTransfersStorePrefix = "ReceivedFileTransfersPrefix"
- receivedTransfersStoreKey = "ReceivedFileTransfers"
- receivedTransfersStoreVersion = 0
-)
-
-// Error messages.
-const (
- // NewOrLoadReceived
- errLoadReceived = "error loading received transfer list from storage: %+v"
- errUnmarshalReceived = "could not unmarshal received transfer list: %+v"
- warnLoadReceivedTransfer = "[FT] failed to load received transfer %d of %d with ID %s: %+v"
- errLoadAllReceivedTransfer = "failed to load all %d transfers"
-
- // Received.AddTransfer
- errAddExistingReceivedTransfer = "received transfer with ID %s already exists in map."
-)
-
-// Received contains a list of all received transfers.
-type Received struct {
- transfers map[ftCrypto.TransferID]*ReceivedTransfer
-
- mux sync.RWMutex
- kv *versioned.KV
-}
-
-// NewOrLoadReceived attempts to load a Received from storage. Or if none exist,
-// then a new Received is returned. Also returns a list of all transfers that
-// have unreceived file parts so their fingerprints can be re-added.
-func NewOrLoadReceived(kv *versioned.KV) (*Received, []*ReceivedTransfer, error) {
- s := &Received{
- transfers: make(map[ftCrypto.TransferID]*ReceivedTransfer),
- kv: kv.Prefix(receivedTransfersStorePrefix),
- }
-
- obj, err := s.kv.Get(receivedTransfersStoreKey, receivedTransfersStoreVersion)
- if err != nil {
- if ekv.Exists(err) {
- return nil, nil, errors.Errorf(errLoadReceived, err)
- } else {
- return s, nil, nil
- }
- }
-
- tidList, err := unmarshalTransferIdList(obj.Data)
- if err != nil {
- return nil, nil, errors.Errorf(errUnmarshalReceived, err)
- }
-
- var errCount int
- unfinishedTransfer := make([]*ReceivedTransfer, 0, len(tidList))
- for i := range tidList {
- tid := tidList[i]
- s.transfers[tid], err = loadReceivedTransfer(&tid, s.kv)
- if err != nil {
- jww.WARN.Print(warnLoadReceivedTransfer, i, len(tidList), tid, err)
- errCount++
- }
-
- if s.transfers[tid].NumReceived() != s.transfers[tid].NumParts() {
- unfinishedTransfer = append(unfinishedTransfer, s.transfers[tid])
- }
- }
-
- // Return an error if all transfers failed to load
- if errCount == len(tidList) {
- return nil, nil, errors.Errorf(errLoadAllReceivedTransfer, len(tidList))
- }
-
- return s, unfinishedTransfer, nil
-}
-
-// AddTransfer adds the ReceivedTransfer to the map keyed on its transfer ID.
-func (r *Received) AddTransfer(key *ftCrypto.TransferKey,
- tid *ftCrypto.TransferID, fileName string, transferMAC []byte,
- fileSize uint32, numParts, numFps uint16) (*ReceivedTransfer, error) {
-
- r.mux.Lock()
- defer r.mux.Unlock()
-
- _, exists := r.transfers[*tid]
- if exists {
- return nil, errors.Errorf(errAddExistingReceivedTransfer, tid)
- }
-
- rt, err := newReceivedTransfer(
- key, tid, fileName, transferMAC, fileSize, numParts, numFps, r.kv)
- if err != nil {
- return nil, err
- }
-
- r.transfers[*tid] = rt
-
- return rt, r.save()
-}
-
-// GetTransfer returns the ReceivedTransfer with the desiccated transfer ID or
-// false if none exists.
-func (r *Received) GetTransfer(tid *ftCrypto.TransferID) (*ReceivedTransfer, bool) {
- r.mux.RLock()
- defer r.mux.RUnlock()
-
- rt, exists := r.transfers[*tid]
- return rt, exists
-}
-
-// RemoveTransfer removes the transfer from the map. If no transfer exists,
-// returns nil. Only errors due to saving to storage are returned.
-func (r *Received) RemoveTransfer(tid *ftCrypto.TransferID) error {
- r.mux.Lock()
- defer r.mux.Unlock()
-
- _, exists := r.transfers[*tid]
- if !exists {
- return nil
- }
-
- delete(r.transfers, *tid)
- return r.save()
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Storage Functions //
-////////////////////////////////////////////////////////////////////////////////
-
-// save stores a list of transfer IDs in the map to storage.
-func (r *Received) save() error {
- data, err := marshalReceivedTransfersMap(r.transfers)
- if err != nil {
- return err
- }
-
- obj := &versioned.Object{
- Version: receivedTransfersStoreVersion,
- Timestamp: netTime.Now(),
- Data: data,
- }
-
- return r.kv.Set(receivedTransfersStoreKey, receivedTransfersStoreVersion, obj)
-}
-
-// marshalReceivedTransfersMap serialises the list of transfer IDs from a
-// ReceivedTransfer map.
-func marshalReceivedTransfersMap(
- transfers map[ftCrypto.TransferID]*ReceivedTransfer) ([]byte, error) {
- tidList := make([]ftCrypto.TransferID, 0, len(transfers))
-
- for tid := range transfers {
- tidList = append(tidList, tid)
- }
-
- return json.Marshal(tidList)
-}
diff --git a/fileTransfer2/store/receivedTransfer.go b/fileTransfer2/store/receivedTransfer.go
deleted file mode 100644
index d067b86635c3c0d77bda84e08afd19904b0ccb00..0000000000000000000000000000000000000000
--- a/fileTransfer2/store/receivedTransfer.go
+++ /dev/null
@@ -1,382 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package store
-
-import (
- "bytes"
- "encoding/base64"
- "encoding/json"
- "github.com/pkg/errors"
- jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/client/fileTransfer2/store/cypher"
- "gitlab.com/elixxir/client/storage/utility"
- "gitlab.com/elixxir/client/storage/versioned"
- ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
- "gitlab.com/xx_network/primitives/netTime"
- "strconv"
- "sync"
-)
-
-// Storage keys and versions.
-const (
- receivedTransferStorePrefix = "ReceivedFileTransferStore/"
- receivedTransferStoreKey = "ReceivedTransfer"
- receivedTransferStoreVersion = 0
- receivedTransferStatusKey = "ReceivedPartStatusVector"
- receivedPartStoreKey = "receivedPart#"
- receivedPartStoreVersion = 0
-)
-
-// Error messages.
-const (
- // newReceivedTransfer
- errRtNewCypherManager = "failed to create new cypher manager: %+v"
- errRtNewPartStatusVectorErr = "failed to create new state vector for part statuses: %+v"
-
- // ReceivedTransfer.AddPart
- errPartOutOfRange = "part number %d out of range of max %d"
- errReceivedPartSave = "failed to save part #%d to storage: %+v"
-
- // loadReceivedTransfer
- errRtLoadCypherManager = "failed to load cypher manager from storage: %+v"
- errRtLoadFields = "failed to load transfer MAC, number of parts, and file size: %+v"
- errRtUnmarshalFields = "failed to unmarshal transfer MAC, number of parts, and file size: %+v"
- errRtLoadPartStatusVector = "failed to load state vector for part statuses: %+v"
- errRtLoadPart = "[FT] Failed to load part #%d from storage: %+v"
-
- // ReceivedTransfer.Delete
- errRtDeleteCypherManager = "failed to delete cypher manager: %+v"
- errRtDeleteSentTransfer = "failed to delete transfer MAC, number of parts, and file size: %+v"
- errRtDeletePartStatus = "failed to delete part status state vector: %+v"
-
- // ReceivedTransfer.save
- errMarshalReceivedTransfer = "failed to marshal: %+v"
-)
-
-// ReceivedTransfer contains information and progress data for a receiving or
-// received file transfer.
-type ReceivedTransfer struct {
- // Tracks file part cyphers
- cypherManager *cypher.Manager
-
- // The ID of the transfer
- tid *ftCrypto.TransferID
-
- // User given name to file
- fileName string
-
- // The MAC for the entire file; used to verify the integrity of all parts
- transferMAC []byte
-
- // Size of the entire file in bytes
- fileSize uint32
-
- // The number of file parts in the file
- numParts uint16
-
- // Saves each part in order (has its own storage backend)
- parts [][]byte
-
- // Stores the received status for each file part in a bitstream format
- partStatus *utility.StateVector
-
- mux sync.RWMutex
- kv *versioned.KV
-}
-
-// newReceivedTransfer generates a ReceivedTransfer with the specified transfer
-// key, transfer ID, and a number of parts.
-func newReceivedTransfer(key *ftCrypto.TransferKey, tid *ftCrypto.TransferID,
- fileName string, transferMAC []byte, fileSize uint32, numParts,
- numFps uint16, kv *versioned.KV) (*ReceivedTransfer, error) {
- kv = kv.Prefix(makeReceivedTransferPrefix(tid))
-
- // Create new cypher manager
- cypherManager, err := cypher.NewManager(key, numFps, kv)
- if err != nil {
- return nil, errors.Errorf(errRtNewCypherManager, err)
- }
-
- // Create new state vector for storing statuses of received parts
- partStatus, err := utility.NewStateVector(
- kv, receivedTransferStatusKey, uint32(numParts))
- if err != nil {
- return nil, errors.Errorf(errRtNewPartStatusVectorErr, err)
- }
-
- rt := &ReceivedTransfer{
- cypherManager: cypherManager,
- tid: tid,
- fileName: fileName,
- transferMAC: transferMAC,
- fileSize: fileSize,
- numParts: numParts,
- parts: make([][]byte, numParts),
- partStatus: partStatus,
- kv: kv,
- }
-
- return rt, rt.save()
-}
-
-// AddPart adds the file part to the list of file parts at the index of partNum.
-func (rt *ReceivedTransfer) AddPart(part []byte, partNum int) error {
- rt.mux.Lock()
- defer rt.mux.Unlock()
-
- if partNum > len(rt.parts)-1 {
- return errors.Errorf(errPartOutOfRange, partNum, len(rt.parts)-1)
- }
-
- // Save part
- rt.parts[partNum] = part
- err := savePart(part, partNum, rt.kv)
- if err != nil {
- return errors.Errorf(errReceivedPartSave, partNum, err)
- }
-
- // Mark part as received
- rt.partStatus.Use(uint32(partNum))
-
- return nil
-}
-
-// GetFile concatenates all file parts and returns it as a single complete file.
-// Note that this function does not care for the completeness of the file and
-// returns all parts it has.
-func (rt *ReceivedTransfer) GetFile() []byte {
- rt.mux.RLock()
- defer rt.mux.RUnlock()
-
- file := bytes.Join(rt.parts, nil)
-
- // Strip off trailing padding from last part
- if len(file) > int(rt.fileSize) {
- file = file[:rt.fileSize]
- }
-
- return file
-}
-
-// GetUnusedCyphers returns a list of cyphers with unused fingerprint numbers.
-func (rt *ReceivedTransfer) GetUnusedCyphers() []cypher.Cypher {
- return rt.cypherManager.GetUnusedCyphers()
-}
-
-// TransferID returns the transfer's ID.
-func (rt *ReceivedTransfer) TransferID() *ftCrypto.TransferID {
- return rt.tid
-}
-
-// FileName returns the transfer's file name.
-func (rt *ReceivedTransfer) FileName() string {
- return rt.fileName
-}
-
-// FileSize returns the size of the entire file transfer.
-func (rt *ReceivedTransfer) FileSize() uint32 {
- return rt.fileSize
-}
-
-// NumParts returns the total number of file parts in the transfer.
-func (rt *ReceivedTransfer) NumParts() uint16 {
- return rt.numParts
-}
-
-// NumReceived returns the number of parts that have been received.
-func (rt *ReceivedTransfer) NumReceived() uint16 {
- rt.mux.RLock()
- defer rt.mux.RUnlock()
- return uint16(rt.partStatus.GetNumUsed())
-}
-
-// CopyPartStatusVector returns a copy of the part status vector that can be
-// used to look up the current status of parts. Note that the statuses are from
-// when this function is called and not realtime.
-func (rt *ReceivedTransfer) CopyPartStatusVector() *utility.StateVector {
- return rt.partStatus.DeepCopy()
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Storage Functions //
-////////////////////////////////////////////////////////////////////////////////
-
-// loadReceivedTransfer loads the ReceivedTransfer with the given transfer ID
-// from storage.
-func loadReceivedTransfer(tid *ftCrypto.TransferID, kv *versioned.KV) (
- *ReceivedTransfer, error) {
- kv = kv.Prefix(makeReceivedTransferPrefix(tid))
-
- // Load cypher manager
- cypherManager, err := cypher.LoadManager(kv)
- if err != nil {
- return nil, errors.Errorf(errRtLoadCypherManager, err)
- }
-
- // Load transfer MAC, number of parts, and file size
- obj, err := kv.Get(receivedTransferStoreKey, receivedTransferStoreVersion)
- if err != nil {
- return nil, errors.Errorf(errRtLoadFields, err)
- }
-
- fileName, transferMAC, numParts, fileSize, err :=
- unmarshalReceivedTransfer(obj.Data)
- if err != nil {
- return nil, errors.Errorf(errRtUnmarshalFields, err)
- }
-
- // Load StateVector for storing statuses of received parts
- partStatus, err := utility.LoadStateVector(kv, receivedTransferStatusKey)
- if err != nil {
- return nil, errors.Errorf(errRtLoadPartStatusVector, err)
- }
-
- // Load parts from storage
- parts := make([][]byte, numParts)
- for i := range parts {
- if partStatus.Used(uint32(i)) {
- parts[i], err = loadPart(i, kv)
- if err != nil {
- jww.ERROR.Printf(errRtLoadPart, i, err)
- }
- }
- }
-
- rt := &ReceivedTransfer{
- cypherManager: cypherManager,
- tid: tid,
- fileName: fileName,
- transferMAC: transferMAC,
- fileSize: fileSize,
- numParts: numParts,
- parts: parts,
- partStatus: partStatus,
- kv: kv,
- }
-
- return rt, nil
-}
-
-// Delete deletes all data in the ReceivedTransfer from storage.
-func (rt *ReceivedTransfer) Delete() error {
- rt.mux.Lock()
- defer rt.mux.Unlock()
-
- // Delete cypher manager
- err := rt.cypherManager.Delete()
- if err != nil {
- return errors.Errorf(errRtDeleteCypherManager, err)
- }
-
- // Delete transfer MAC, number of parts, and file size
- err = rt.kv.Delete(receivedTransferStoreKey, receivedTransferStoreVersion)
- if err != nil {
- return errors.Errorf(errRtDeleteSentTransfer, err)
- }
-
- // Delete part status state vector
- err = rt.partStatus.Delete()
- if err != nil {
- return errors.Errorf(errRtDeletePartStatus, err)
- }
-
- return nil
-}
-
-// save stores all fields in ReceivedTransfer that do not have their own storage
-// (transfer MAC, file size, and number of file parts) to storage.
-func (rt *ReceivedTransfer) save() error {
- data, err := rt.marshal()
- if err != nil {
- return errors.Errorf(errMarshalReceivedTransfer, err)
- }
-
- // Create new versioned object for the ReceivedTransfer
- vo := &versioned.Object{
- Version: receivedTransferStoreVersion,
- Timestamp: netTime.Now(),
- Data: data,
- }
-
- // Save versioned object
- return rt.kv.Set(receivedTransferStoreKey, receivedTransferStoreVersion, vo)
-}
-
-// receivedTransferDisk structure is used to marshal and unmarshal
-// ReceivedTransfer fields to/from storage.
-type receivedTransferDisk struct {
- FileName string
- TransferMAC []byte
- NumParts uint16
- FileSize uint32
-}
-
-// marshal serialises the ReceivedTransfer's fileName, transferMAC, numParts,
-// and fileSize.
-func (rt *ReceivedTransfer) marshal() ([]byte, error) {
- disk := receivedTransferDisk{
- FileName: rt.fileName,
- TransferMAC: rt.transferMAC,
- NumParts: rt.numParts,
- FileSize: rt.fileSize,
- }
-
- return json.Marshal(disk)
-}
-
-// unmarshalReceivedTransfer deserializes the data into the fileName,
-// transferMAC, numParts, and fileSize.
-func unmarshalReceivedTransfer(data []byte) (fileName string,
- transferMAC []byte, numParts uint16, fileSize uint32, err error) {
- var disk receivedTransferDisk
- err = json.Unmarshal(data, &disk)
- if err != nil {
- return "", nil, 0, 0, err
- }
-
- return disk.FileName, disk.TransferMAC, disk.NumParts, disk.FileSize, nil
-}
-
-// savePart saves the given part to storage keying on its part number.
-func savePart(part []byte, partNum int, kv *versioned.KV) error {
- obj := &versioned.Object{
- Version: receivedPartStoreVersion,
- Timestamp: netTime.Now(),
- Data: part,
- }
-
- return kv.Set(makeReceivedPartKey(partNum), receivedPartStoreVersion, obj)
-}
-
-// loadPart loads the part with the given part number from storage.
-func loadPart(partNum int, kv *versioned.KV) ([]byte, error) {
- obj, err := kv.Get(makeReceivedPartKey(partNum), receivedPartStoreVersion)
- if err != nil {
- return nil, err
- }
- return obj.Data, nil
-}
-
-// makeReceivedTransferPrefix generates the unique prefix used on the key value
-// store to store received transfers for the given transfer ID.
-func makeReceivedTransferPrefix(tid *ftCrypto.TransferID) string {
- return receivedTransferStorePrefix +
- base64.StdEncoding.EncodeToString(tid.Bytes())
-}
-
-// makeReceivedPartKey generates a storage key for the given part number.
-func makeReceivedPartKey(partNum int) string {
- return receivedPartStoreKey + strconv.Itoa(partNum)
-}
diff --git a/fileTransfer2/store/receivedTransfer_test.go b/fileTransfer2/store/receivedTransfer_test.go
deleted file mode 100644
index 09da21e307c60f7dd277e675afa51e1894a404b2..0000000000000000000000000000000000000000
--- a/fileTransfer2/store/receivedTransfer_test.go
+++ /dev/null
@@ -1,466 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package store
-
-import (
- "bytes"
- "fmt"
- "gitlab.com/elixxir/client/fileTransfer2/store/cypher"
- "gitlab.com/elixxir/client/storage/utility"
- "gitlab.com/elixxir/client/storage/versioned"
- ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
- "gitlab.com/elixxir/ekv"
- "gitlab.com/xx_network/crypto/csprng"
- "reflect"
- "testing"
-)
-
-// Tests that newReceivedTransfer returns a new ReceivedTransfer with the
-// expected values.
-func Test_newReceivedTransfer(t *testing.T) {
- kv := versioned.NewKV(ekv.MakeMemstore())
- key, _ := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
- tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
- numFps := uint16(24)
- parts, _ := generateTestParts(16)
- fileSize := uint32(len(parts) * len(parts[0]))
- numParts := uint16(len(parts))
- rtKv := kv.Prefix(makeReceivedTransferPrefix(&tid))
-
- cypherManager, err := cypher.NewManager(&key, numFps, rtKv)
- if err != nil {
- t.Errorf("Failed to make new cypher manager: %+v", err)
- }
- partStatus, err := utility.NewStateVector(
- rtKv, receivedTransferStatusKey, uint32(numParts))
- if err != nil {
- t.Errorf("Failed to make new state vector: %+v", err)
- }
-
- expected := &ReceivedTransfer{
- cypherManager: cypherManager,
- tid: &tid,
- fileName: "fileName",
- transferMAC: []byte("transferMAC"),
- fileSize: fileSize,
- numParts: numParts,
- parts: make([][]byte, numParts),
- partStatus: partStatus,
- kv: rtKv,
- }
-
- rt, err := newReceivedTransfer(&key, &tid, expected.fileName,
- expected.transferMAC, fileSize, numParts, numFps, kv)
- if err != nil {
- t.Errorf("newReceivedTransfer returned an error: %+v", err)
- }
-
- if !reflect.DeepEqual(expected, rt) {
- t.Errorf("New ReceivedTransfer does not match expected."+
- "\nexpected: %+v\nreceived: %+v", expected, rt)
- }
-}
-
-// Tests that ReceivedTransfer.AddPart adds the part to the part list and marks
-// it as received
-func TestReceivedTransfer_AddPart(t *testing.T) {
- rt, _, _, _, _ := newTestReceivedTransfer(16, t)
-
- part := []byte("Part")
- partNum := 6
-
- err := rt.AddPart(part, partNum)
- if err != nil {
- t.Errorf("Failed to add part: %+v", err)
- }
-
- if !bytes.Equal(rt.parts[partNum], part) {
- t.Errorf("Found incorrect part in list.\nexpected: %q\nreceived: %q",
- part, rt.parts[partNum])
- }
-
- if !rt.partStatus.Used(uint32(partNum)) {
- t.Errorf("Part #%d not marked as received.", partNum)
- }
-}
-
-// Tests that ReceivedTransfer.AddPart returns an error if the part number is
-// not within the range of part numbers
-func TestReceivedTransfer_AddPart_PartOutOfRangeError(t *testing.T) {
- rt, _, _, _, _ := newTestReceivedTransfer(16, t)
-
- expectedErr := fmt.Sprintf(errPartOutOfRange, rt.partStatus.GetNumKeys(),
- rt.partStatus.GetNumKeys()-1)
-
- err := rt.AddPart([]byte("Part"), int(rt.partStatus.GetNumKeys()))
- if err == nil || err.Error() != expectedErr {
- t.Errorf("Failed to get expected error when part number is out of range."+
- "\nexpected: %s\nreceived: %+v", expectedErr, err)
- }
-}
-
-// Tests that ReceivedTransfer.GetFile returns the expected file after all the
-// parts are added to the transfer.
-func TestReceivedTransfer_GetFile(t *testing.T) {
- // Generate parts and make last file part smaller than the rest
- parts, _ := generateTestParts(16)
- lastPartLen := 6
- rt, _, _, _, _ := newTestReceivedTransfer(uint16(len(parts)), t)
- rt.fileSize = uint32((len(parts)-1)*len(parts[0]) + lastPartLen)
-
- for i, p := range parts {
- err := rt.AddPart(p, i)
- if err != nil {
- t.Errorf("Failed to add part #%d: %+v", i, err)
- }
- }
-
- parts[len(parts)-1] = parts[len(parts)-1][:lastPartLen]
- combinedParts := bytes.Join(parts, nil)
-
- file := rt.GetFile()
-
- if !bytes.Equal(file, combinedParts) {
- t.Errorf("Received file does not match expected."+
- "\nexpected: %q\nreceived: %q", combinedParts, file)
- }
-
-}
-
-// Tests that ReceivedTransfer.GetUnusedCyphers returns the correct number of
-// unused cyphers.
-func TestReceivedTransfer_GetUnusedCyphers(t *testing.T) {
- numParts := uint16(10)
- rt, _, _, numFps, _ := newTestReceivedTransfer(numParts, t)
-
- // Check that all cyphers are returned after initialisation
- unsentCyphers := rt.GetUnusedCyphers()
- if len(unsentCyphers) != int(numFps) {
- t.Errorf("Number of unused cyphers does not match original number of "+
- "fingerprints when none have been used.\nexpected: %d\nreceived: %d",
- numFps, len(unsentCyphers))
- }
-
- // Use every other part
- for i := range unsentCyphers {
- if i%2 == 0 {
- _, _ = unsentCyphers[i].PopCypher()
- }
- }
-
- // Check that only have the number of parts is returned
- unsentCyphers = rt.GetUnusedCyphers()
- if len(unsentCyphers) != int(numFps)/2 {
- t.Errorf("Number of unused cyphers is not half original number after "+
- "half have been marked as received.\nexpected: %d\nreceived: %d",
- numFps/2, len(unsentCyphers))
- }
-
- // Use the rest of the parts
- for i := range unsentCyphers {
- _, _ = unsentCyphers[i].PopCypher()
- }
-
- // Check that no sent parts are returned
- unsentCyphers = rt.GetUnusedCyphers()
- if len(unsentCyphers) != 0 {
- t.Errorf("Number of unused cyphers is not zero after all have been "+
- "marked as received.\nexpected: %d\nreceived: %d",
- 0, len(unsentCyphers))
- }
-}
-
-// Tests that ReceivedTransfer.TransferID returns the correct transfer ID.
-func TestReceivedTransfer_TransferID(t *testing.T) {
- rt, _, _, _, _ := newTestReceivedTransfer(16, t)
-
- if rt.TransferID() != rt.tid {
- t.Errorf("Incorrect transfer ID.\nexpected: %s\nreceived: %s",
- rt.tid, rt.TransferID())
- }
-}
-
-// Tests that ReceivedTransfer.FileName returns the correct file name.
-func TestReceivedTransfer_FileName(t *testing.T) {
- rt, _, _, _, _ := newTestReceivedTransfer(16, t)
-
- if rt.FileName() != rt.fileName {
- t.Errorf("Incorrect transfer ID.\nexpected: %s\nreceived: %s",
- rt.fileName, rt.FileName())
- }
-}
-
-// Tests that ReceivedTransfer.FileSize returns the correct file size.
-func TestReceivedTransfer_FileSize(t *testing.T) {
- rt, file, _, _, _ := newTestReceivedTransfer(16, t)
- fileSize := uint32(len(file))
-
- if rt.FileSize() != fileSize {
- t.Errorf("Incorrect file size.\nexpected: %d\nreceived: %d",
- fileSize, rt.FileSize())
- }
-}
-
-// Tests that ReceivedTransfer.NumParts returns the correct number of parts.
-func TestReceivedTransfer_NumParts(t *testing.T) {
- numParts := uint16(16)
- rt, _, _, _, _ := newTestReceivedTransfer(numParts, t)
-
- if rt.NumParts() != numParts {
- t.Errorf("Incorrect number of parts.\nexpected: %d\nreceived: %d",
- numParts, rt.NumParts())
- }
-}
-
-// Tests that ReceivedTransfer.NumReceived returns the correct number of
-// received parts.
-func TestReceivedTransfer_NumReceived(t *testing.T) {
- rt, _, _, _, _ := newTestReceivedTransfer(16, t)
-
- if rt.NumReceived() != 0 {
- t.Errorf("Incorrect number of received parts."+
- "\nexpected: %d\nreceived: %d", 0, rt.NumReceived())
- }
-
- // Add all parts as received
- for i := 0; i < int(rt.numParts); i++ {
- _ = rt.AddPart(nil, i)
- }
-
- if uint32(rt.NumReceived()) != rt.partStatus.GetNumKeys() {
- t.Errorf("Incorrect number of received parts."+
- "\nexpected: %d\nreceived: %d",
- uint32(rt.NumReceived()), rt.partStatus.GetNumKeys())
- }
-}
-
-// Tests that the state vector returned by ReceivedTransfer.CopyPartStatusVector
-// has the same values as the original but is a copy.
-func TestReceivedTransfer_CopyPartStatusVector(t *testing.T) {
- rt, _, _, _, _ := newTestReceivedTransfer(64, t)
-
- // Check that the vectors have the same unused parts
- partStatus := rt.CopyPartStatusVector()
- if !reflect.DeepEqual(
- partStatus.GetUnusedKeyNums(), rt.partStatus.GetUnusedKeyNums()) {
- t.Errorf("Copied part status does not match original."+
- "\nexpected: %v\nreceived: %v",
- rt.partStatus.GetUnusedKeyNums(), partStatus.GetUnusedKeyNums())
- }
-
- // Modify the state
- _ = rt.AddPart([]byte("hello"), 5)
-
- // Check that the copied state is different
- if reflect.DeepEqual(
- partStatus.GetUnusedKeyNums(), rt.partStatus.GetUnusedKeyNums()) {
- t.Errorf("Old copied part status matches new status."+
- "\nexpected: %v\nreceived: %v",
- rt.partStatus.GetUnusedKeyNums(), partStatus.GetUnusedKeyNums())
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Storage Functions //
-////////////////////////////////////////////////////////////////////////////////
-
-// Tests that a ReceivedTransfer loaded via loadReceivedTransfer matches the
-// original.
-func Test_loadReceivedTransfer(t *testing.T) {
- parts, _ := generateTestParts(16)
- rt, _, _, _, kv := newTestReceivedTransfer(uint16(len(parts)), t)
-
- for i, p := range parts {
- if i%2 == 0 {
-
- err := rt.AddPart(p, i)
- if err != nil {
- t.Errorf("Failed to add part #%d: %+v", i, err)
- }
- }
- }
-
- loadedRt, err := loadReceivedTransfer(rt.tid, kv)
- if err != nil {
- t.Errorf("Failed to load ReceivedTransfer: %+v", err)
- }
-
- if !reflect.DeepEqual(rt, loadedRt) {
- t.Errorf("Loaded ReceivedTransfer does not match original."+
- "\nexpected: %+v\nreceived: %+v", rt, loadedRt)
- }
-}
-
-// Tests that ReceivedTransfer.Delete deletes the storage backend of the
-// ReceivedTransfer and that it cannot be loaded again.
-func TestReceivedTransfer_Delete(t *testing.T) {
- rt, _, _, _, kv := newTestReceivedTransfer(64, t)
-
- err := rt.Delete()
- if err != nil {
- t.Errorf("Delete returned an error: %+v", err)
- }
-
- _, err = loadSentTransfer(rt.tid, kv)
- if err == nil {
- t.Errorf("Loaded received transfer that was deleted.")
- }
-}
-
-// Tests that the fields saved by ReceivedTransfer.save can be loaded from
-// storage.
-func TestReceivedTransfer_save(t *testing.T) {
- rt, _, _, _, _ := newTestReceivedTransfer(64, t)
-
- err := rt.save()
- if err != nil {
- t.Errorf("save returned an error: %+v", err)
- }
-
- _, err = rt.kv.Get(receivedTransferStoreKey, receivedTransferStoreVersion)
- if err != nil {
- t.Errorf("Failed to load saved ReceivedTransfer: %+v", err)
- }
-}
-
-// newTestReceivedTransfer creates a new ReceivedTransfer for testing.
-func newTestReceivedTransfer(numParts uint16, t *testing.T) (
- rt *ReceivedTransfer, file []byte, key *ftCrypto.TransferKey,
- numFps uint16, kv *versioned.KV) {
- kv = versioned.NewKV(ekv.MakeMemstore())
- keyTmp, _ := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
- tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
- transferMAC := []byte("I am a transfer MAC")
- numFps = 2 * numParts
- fileName := "helloFile"
- _, file = generateTestParts(numParts)
- fileSize := uint32(len(file))
-
- st, err := newReceivedTransfer(
- &keyTmp, &tid, fileName, transferMAC, fileSize, numParts, numFps, kv)
- if err != nil {
- t.Errorf("Failed to make new SentTransfer: %+v", err)
- }
-
- return st, file, &keyTmp, numFps, kv
-}
-
-// Tests that a ReceivedTransfer marshalled via ReceivedTransfer.marshal and
-// unmarshalled via unmarshalReceivedTransfer matches the original.
-func TestReceivedTransfer_marshal_unmarshalReceivedTransfer(t *testing.T) {
- rt := &ReceivedTransfer{
- fileName: "transferName",
- transferMAC: []byte("I am a transfer MAC"),
- fileSize: 735,
- numParts: 153,
- }
-
- data, err := rt.marshal()
- if err != nil {
- t.Errorf("marshal returned an error: %+v", err)
- }
-
- fileName, transferMac, numParts, fileSize, err :=
- unmarshalReceivedTransfer(data)
- if err != nil {
- t.Errorf("Failed to unmarshal SentTransfer: %+v", err)
- }
-
- if rt.fileName != fileName {
- t.Errorf("Incorrect file name.\nexpected: %q\nreceived: %q",
- rt.fileName, fileName)
- }
-
- if !bytes.Equal(rt.transferMAC, transferMac) {
- t.Errorf("Incorrect transfer MAC.\nexpected: %s\nreceived: %s",
- rt.transferMAC, transferMac)
- }
-
- if rt.numParts != numParts {
- t.Errorf("Incorrect number of parts.\nexpected: %d\nreceived: %d",
- rt.numParts, numParts)
- }
-
- if rt.fileSize != fileSize {
- t.Errorf("Incorrect file size.\nexpected: %d\nreceived: %d",
- rt.fileSize, fileSize)
- }
-}
-
-// Tests that the part saved to storage via savePart can be loaded.
-func Test_savePart_loadPart(t *testing.T) {
- kv := versioned.NewKV(ekv.MakeMemstore())
- part := []byte("I am a part.")
- partNum := 18
-
- err := savePart(part, partNum, kv)
- if err != nil {
- t.Errorf("Failed to save part: %+v", err)
- }
-
- loadedPart, err := loadPart(partNum, kv)
- if err != nil {
- t.Errorf("Failed to load part: %+v", err)
- }
-
- if !bytes.Equal(part, loadedPart) {
- t.Errorf("Loaded part does not match original."+
- "\nexpected: %q\nreceived: %q", part, loadedPart)
- }
-}
-
-// Consistency test of makeReceivedTransferPrefix.
-func Test_makeReceivedTransferPrefix_Consistency(t *testing.T) {
- expectedPrefixes := []string{
- "ReceivedFileTransferStore/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
- "ReceivedFileTransferStore/AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
- "ReceivedFileTransferStore/AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
- "ReceivedFileTransferStore/AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
- "ReceivedFileTransferStore/BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
- "ReceivedFileTransferStore/BQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
- "ReceivedFileTransferStore/BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
- "ReceivedFileTransferStore/BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
- "ReceivedFileTransferStore/CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
- "ReceivedFileTransferStore/CQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
- }
-
- for i, expected := range expectedPrefixes {
- tid := ftCrypto.TransferID{byte(i)}
- prefix := makeReceivedTransferPrefix(&tid)
-
- if expected != prefix {
- t.Errorf("Prefix #%d does not match expected."+
- "\nexpected: %q\nreceived: %q", i, expected, prefix)
- }
- }
-}
-
-// Consistency test of makeReceivedPartKey.
-func Test_makeReceivedPartKey_Consistency(t *testing.T) {
- expectedKeys := []string{
- "receivedPart#0", "receivedPart#1", "receivedPart#2", "receivedPart#3",
- "receivedPart#4", "receivedPart#5", "receivedPart#6", "receivedPart#7",
- "receivedPart#8", "receivedPart#9",
- }
-
- for i, expected := range expectedKeys {
- key := makeReceivedPartKey(i)
-
- if expected != key {
- t.Errorf("Key #%d does not match expected."+
- "\nexpected: %q\nreceived: %q", i, expected, key)
- }
- }
-}
diff --git a/fileTransfer2/store/received_test.go b/fileTransfer2/store/received_test.go
deleted file mode 100644
index be7652ec9abb9784a667d6b6e7ba715d76fc1135..0000000000000000000000000000000000000000
--- a/fileTransfer2/store/received_test.go
+++ /dev/null
@@ -1,262 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package store
-
-import (
- "bytes"
- "fmt"
- "gitlab.com/elixxir/client/storage/versioned"
- ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
- "gitlab.com/elixxir/ekv"
- "gitlab.com/xx_network/crypto/csprng"
- "reflect"
- "sort"
- "strconv"
- "testing"
-)
-
-// Tests that NewOrLoadReceived returns a new Received when none exist in
-// storage and that the list of incomplete transfers is nil.
-func TestNewOrLoadReceived_New(t *testing.T) {
- kv := versioned.NewKV(ekv.MakeMemstore())
- expected := &Received{
- transfers: make(map[ftCrypto.TransferID]*ReceivedTransfer),
- kv: kv.Prefix(receivedTransfersStorePrefix),
- }
-
- r, incompleteTransfers, err := NewOrLoadReceived(kv)
- if err != nil {
- t.Errorf("NewOrLoadReceived returned an error: %+v", err)
- }
-
- if !reflect.DeepEqual(expected, r) {
- t.Errorf("New Received does not match expected."+
- "\nexpected: %+v\nreceived: %+v", expected, r)
- }
-
- if incompleteTransfers != nil {
- t.Errorf("List of incomplete transfers should be nil when not "+
- "loading: %+v", incompleteTransfers)
- }
-}
-
-// Tests that NewOrLoadReceived returns a loaded Received when one exist in
-// storage and that the list of incomplete transfers is correct.
-func TestNewOrLoadReceived_Load(t *testing.T) {
- kv := versioned.NewKV(ekv.MakeMemstore())
- r, _, err := NewOrLoadReceived(kv)
- if err != nil {
- t.Errorf("Failed to make new Received: %+v", err)
- }
- var expectedIncompleteTransfers []*ReceivedTransfer
-
- // Create and add transfers to map and save
- for i := 0; i < 2; i++ {
- key, _ := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
- tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
- rt, err2 := r.AddTransfer(&key, &tid, "file"+strconv.Itoa(i),
- []byte("transferMAC"+strconv.Itoa(i)), 128, 10, 20)
- if err2 != nil {
- t.Errorf("Failed to add transfer #%d: %+v", i, err2)
- }
- expectedIncompleteTransfers = append(expectedIncompleteTransfers, rt)
- }
- if err = r.save(); err != nil {
- t.Errorf("Failed to make save filled Receivced: %+v", err)
- }
-
- // Load Received
- loadedReceived, incompleteTransfers, err := NewOrLoadReceived(kv)
- if err != nil {
- t.Errorf("Failed to load Received: %+v", err)
- }
-
- // Check that the loaded Received matches original
- if !reflect.DeepEqual(r, loadedReceived) {
- t.Errorf("Loaded Received does not match original."+
- "\nexpected: %#v\nreceived: %#v", r, loadedReceived)
- }
-
- sort.Slice(incompleteTransfers, func(i, j int) bool {
- return bytes.Compare(incompleteTransfers[i].TransferID()[:],
- incompleteTransfers[j].TransferID()[:]) == -1
- })
-
- sort.Slice(expectedIncompleteTransfers, func(i, j int) bool {
- return bytes.Compare(expectedIncompleteTransfers[i].TransferID()[:],
- expectedIncompleteTransfers[j].TransferID()[:]) == -1
- })
-
- // Check that the incomplete transfers matches expected
- if !reflect.DeepEqual(expectedIncompleteTransfers, incompleteTransfers) {
- t.Errorf("Incorrect incomplete transfers.\nexpected: %v\nreceived: %v",
- expectedIncompleteTransfers, incompleteTransfers)
- }
-}
-
-// Tests that Received.AddTransfer makes a new transfer and adds it to the list.
-func TestReceived_AddTransfer(t *testing.T) {
- kv := versioned.NewKV(ekv.MakeMemstore())
- r, _, _ := NewOrLoadReceived(kv)
-
- key, _ := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
- tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
-
- rt, err := r.AddTransfer(
- &key, &tid, "file", []byte("transferMAC"), 128, 10, 20)
- if err != nil {
- t.Errorf("Failed to add new transfer: %+v", err)
- }
-
- // Check that the transfer was added
- if _, exists := r.transfers[*rt.tid]; !exists {
- t.Errorf("No transfer with ID %s exists.", rt.tid)
- }
-}
-
-// Tests that Received.AddTransfer returns an error when adding a transfer ID
-// that already exists.
-func TestReceived_AddTransfer_TransferAlreadyExists(t *testing.T) {
- tid := ftCrypto.TransferID{0}
- r := &Received{
- transfers: map[ftCrypto.TransferID]*ReceivedTransfer{tid: nil},
- }
-
- expectedErr := fmt.Sprintf(errAddExistingReceivedTransfer, tid)
- _, err := r.AddTransfer(nil, &tid, "", nil, 0, 0, 0)
- if err == nil || err.Error() != expectedErr {
- t.Errorf("Received unexpected error when adding transfer that already "+
- "exists.\nexpected: %s\nreceived: %+v", expectedErr, err)
- }
-}
-
-// Tests that Received.GetTransfer returns the expected transfer.
-func TestReceived_GetTransfer(t *testing.T) {
- kv := versioned.NewKV(ekv.MakeMemstore())
- r, _, _ := NewOrLoadReceived(kv)
-
- key, _ := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
- tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
-
- rt, err := r.AddTransfer(
- &key, &tid, "file", []byte("transferMAC"), 128, 10, 20)
- if err != nil {
- t.Errorf("Failed to add new transfer: %+v", err)
- }
-
- // Check that the transfer was added
- receivedRt, exists := r.GetTransfer(rt.tid)
- if !exists {
- t.Errorf("No transfer with ID %s exists.", rt.tid)
- }
-
- if !reflect.DeepEqual(rt, receivedRt) {
- t.Errorf("Received ReceivedTransfer does not match expected."+
- "\nexpected: %+v\nreceived: %+v", rt, receivedRt)
- }
-}
-
-// Tests that Sent.RemoveTransfer removes the transfer from the list.
-func TestReceived_RemoveTransfer(t *testing.T) {
- kv := versioned.NewKV(ekv.MakeMemstore())
- r, _, _ := NewOrLoadReceived(kv)
-
- key, _ := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
- tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
-
- rt, err := r.AddTransfer(
- &key, &tid, "file", []byte("transferMAC"), 128, 10, 20)
- if err != nil {
- t.Errorf("Failed to add new transfer: %+v", err)
- }
-
- // Delete the transfer
- err = r.RemoveTransfer(rt.tid)
- if err != nil {
- t.Errorf("RemoveTransfer returned an error: %+v", err)
- }
-
- // Check that the transfer was deleted
- _, exists := r.GetTransfer(rt.tid)
- if exists {
- t.Errorf("Transfer %s exists.", rt.tid)
- }
-
- // Remove transfer that was already removed
- err = r.RemoveTransfer(rt.tid)
- if err != nil {
- t.Errorf("RemoveTransfer returned an error: %+v", err)
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Storage Functions //
-////////////////////////////////////////////////////////////////////////////////
-
-// Tests that Received.save saves the transfer ID list to storage by trying to
-// load it after a save.
-func TestReceived_save(t *testing.T) {
- kv := versioned.NewKV(ekv.MakeMemstore())
- r, _, _ := NewOrLoadReceived(kv)
- r.transfers = map[ftCrypto.TransferID]*ReceivedTransfer{
- ftCrypto.TransferID{0}: nil, ftCrypto.TransferID{1}: nil,
- ftCrypto.TransferID{2}: nil, ftCrypto.TransferID{3}: nil,
- }
-
- err := r.save()
- if err != nil {
- t.Errorf("Failed to save transfer ID list: %+v", err)
- }
-
- _, err = r.kv.Get(receivedTransfersStoreKey, receivedTransfersStoreVersion)
- if err != nil {
- t.Errorf("Failed to load transfer ID list: %+v", err)
- }
-}
-
-// Tests that the transfer IDs keys in the map marshalled by
-// marshalReceivedTransfersMap and unmarshalled by unmarshalTransferIdList match
-// the original.
-func Test_marshalReceivedTransfersMap_unmarshalTransferIdList(t *testing.T) {
- // Build map of transfer IDs
- transfers := make(map[ftCrypto.TransferID]*ReceivedTransfer, 10)
- for i := 0; i < 10; i++ {
- tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
- transfers[tid] = nil
- }
-
- data, err := marshalReceivedTransfersMap(transfers)
- if err != nil {
- t.Errorf("marshalReceivedTransfersMap returned an error: %+v", err)
- }
-
- tidList, err := unmarshalTransferIdList(data)
- if err != nil {
- t.Errorf("unmarshalSentTransfer returned an error: %+v", err)
- }
-
- for _, tid := range tidList {
- if _, exists := transfers[tid]; exists {
- delete(transfers, tid)
- } else {
- t.Errorf("Transfer %s does not exist in list.", tid)
- }
- }
-
- if len(transfers) != 0 {
- t.Errorf("%d transfers not in unmarshalled list: %v",
- len(transfers), transfers)
- }
-}
diff --git a/fileTransfer2/store/sent.go b/fileTransfer2/store/sent.go
deleted file mode 100644
index 7873d5b469bafc8666b0951d55d7852aff0c1ae6..0000000000000000000000000000000000000000
--- a/fileTransfer2/store/sent.go
+++ /dev/null
@@ -1,193 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package store
-
-import (
- "encoding/json"
- "github.com/pkg/errors"
- jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/client/storage/versioned"
- ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
- "gitlab.com/elixxir/ekv"
- "gitlab.com/xx_network/primitives/id"
- "gitlab.com/xx_network/primitives/netTime"
- "sync"
-)
-
-// Storage keys and versions.
-const (
- sentTransfersStorePrefix = "SentFileTransfersPrefix"
- sentTransfersStoreKey = "SentFileTransfers"
- sentTransfersStoreVersion = 0
-)
-
-// Error messages.
-const (
- // NewOrLoadSent
- errLoadSent = "error loading sent transfer list from storage: %+v"
- errUnmarshalSent = "could not unmarshal sent transfer list: %+v"
- warnLoadSentTransfer = "[FT] Failed to load sent transfer %d of %d with ID %s: %+v"
- errLoadAllSentTransfer = "failed to load all %d transfers"
-
- // Sent.AddTransfer
- errAddExistingSentTransfer = "sent transfer with ID %s already exists in map."
- errNewSentTransfer = "failed to make new sent transfer: %+v"
-)
-
-// Sent contains a list of all sent transfers.
-type Sent struct {
- transfers map[ftCrypto.TransferID]*SentTransfer
-
- mux sync.RWMutex
- kv *versioned.KV
-}
-
-// NewOrLoadSent attempts to load Sent from storage. Or if none exist, then a
-// new Sent is returned. If running transfers were loaded from storage, a list
-// of unsent parts is returned.
-func NewOrLoadSent(kv *versioned.KV) (*Sent, []Part, error) {
- s := &Sent{
- transfers: make(map[ftCrypto.TransferID]*SentTransfer),
- kv: kv.Prefix(sentTransfersStorePrefix),
- }
-
- obj, err := s.kv.Get(sentTransfersStoreKey, sentTransfersStoreVersion)
- if err != nil {
- if !ekv.Exists(err) {
- // Return the new Sent if none exists in storage
- return s, nil, nil
- } else {
- // Return other errors
- return nil, nil, errors.Errorf(errLoadSent, err)
- }
- }
-
- // Load list of saved sent transfers from storage
- tidList, err := unmarshalTransferIdList(obj.Data)
- if err != nil {
- return nil, nil, errors.Errorf(errUnmarshalSent, err)
- }
-
- // Load sent transfers from storage
- var errCount int
- var unsentParts []Part
- for i := range tidList {
- tid := tidList[i]
- s.transfers[tid], err = loadSentTransfer(&tid, s.kv)
- if err != nil {
- jww.WARN.Printf(warnLoadSentTransfer, i, len(tidList), tid, err)
- errCount++
- continue
- }
-
- if s.transfers[tid].Status() == Running {
- unsentParts =
- append(unsentParts, s.transfers[tid].GetUnsentParts()...)
- }
- }
-
- // Return an error if all transfers failed to load
- if errCount == len(tidList) {
- return nil, nil, errors.Errorf(errLoadAllSentTransfer, len(tidList))
- }
-
- return s, unsentParts, nil
-}
-
-// AddTransfer creates a SentTransfer and adds it to the map keyed on its
-// transfer ID.
-func (s *Sent) AddTransfer(recipient *id.ID, key *ftCrypto.TransferKey,
- tid *ftCrypto.TransferID, fileName string, fileSize uint32, parts [][]byte,
- numFps uint16) (*SentTransfer, error) {
- s.mux.Lock()
- defer s.mux.Unlock()
-
- _, exists := s.transfers[*tid]
- if exists {
- return nil, errors.Errorf(errAddExistingSentTransfer, tid)
- }
-
- st, err := newSentTransfer(
- recipient, key, tid, fileName, fileSize, parts, numFps, s.kv)
- if err != nil {
- return nil, errors.Errorf(errNewSentTransfer, tid)
- }
-
- s.transfers[*tid] = st
-
- return st, s.save()
-}
-
-// GetTransfer returns the SentTransfer with the desiccated transfer ID or false
-// if none exists.
-func (s *Sent) GetTransfer(tid *ftCrypto.TransferID) (*SentTransfer, bool) {
- s.mux.RLock()
- defer s.mux.RUnlock()
-
- st, exists := s.transfers[*tid]
- return st, exists
-}
-
-// RemoveTransfer removes the transfer from the map. If no transfer exists,
-// returns nil. Only errors due to saving to storage are returned.
-func (s *Sent) RemoveTransfer(tid *ftCrypto.TransferID) error {
- s.mux.Lock()
- defer s.mux.Unlock()
-
- _, exists := s.transfers[*tid]
- if !exists {
- return nil
- }
-
- delete(s.transfers, *tid)
- return s.save()
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Storage Functions //
-////////////////////////////////////////////////////////////////////////////////
-
-// save stores a list of transfer IDs in the map to storage.
-func (s *Sent) save() error {
- data, err := marshalSentTransfersMap(s.transfers)
- if err != nil {
- return err
- }
-
- obj := &versioned.Object{
- Version: sentTransfersStoreVersion,
- Timestamp: netTime.Now(),
- Data: data,
- }
-
- return s.kv.Set(sentTransfersStoreKey, sentTransfersStoreVersion, obj)
-}
-
-// marshalSentTransfersMap serialises the list of transfer IDs from a
-// SentTransfer map.
-func marshalSentTransfersMap(transfers map[ftCrypto.TransferID]*SentTransfer) (
- []byte, error) {
- tidList := make([]ftCrypto.TransferID, 0, len(transfers))
-
- for tid := range transfers {
- tidList = append(tidList, tid)
- }
-
- return json.Marshal(tidList)
-}
-
-// unmarshalTransferIdList deserializes the data into a list of transfer IDs.
-func unmarshalTransferIdList(data []byte) ([]ftCrypto.TransferID, error) {
- var tidList []ftCrypto.TransferID
- err := json.Unmarshal(data, &tidList)
- if err != nil {
- return nil, err
- }
-
- return tidList, nil
-}
diff --git a/fileTransfer2/store/sentTransfer.go b/fileTransfer2/store/sentTransfer.go
deleted file mode 100644
index 9891087a1d07193eabb6da92749de0c448d8a68f..0000000000000000000000000000000000000000
--- a/fileTransfer2/store/sentTransfer.go
+++ /dev/null
@@ -1,364 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package store
-
-import (
- "encoding/base64"
- "encoding/json"
- "github.com/pkg/errors"
- jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/client/fileTransfer2/store/cypher"
- "gitlab.com/elixxir/client/storage/utility"
- "gitlab.com/elixxir/client/storage/versioned"
- ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
- "gitlab.com/xx_network/primitives/id"
- "gitlab.com/xx_network/primitives/netTime"
- "sync"
-)
-
-// Storage keys and versions.
-const (
- sentTransferStorePrefix = "SentFileTransferStore/"
- sentTransferStoreKey = "SentTransfer"
- sentTransferStoreVersion = 0
- sentTransferStatusKey = "SentPartStatusVector"
-)
-
-// Error messages.
-const (
- // newSentTransfer
- errStNewCypherManager = "failed to create new cypher manager: %+v"
- errStNewPartStatusVector = "failed to create new state vector for part statuses: %+v"
-
- // SentTransfer.getPartData
- errNoPartNum = "no part with part number %d exists in transfer %s (%q)"
-
- // loadSentTransfer
- errStLoadCypherManager = "failed to load cypher manager from storage: %+v"
- errStLoadFields = "failed to load recipient, status, and parts list: %+v"
- errStUnmarshalFields = "failed to unmarshal recipient, status, and parts list: %+v"
- errStLoadPartStatusVector = "failed to load state vector for part statuses: %+v"
-
- // SentTransfer.Delete
- errStDeleteCypherManager = "failed to delete cypherManager: %+v"
- errStDeleteSentTransfer = "failed to delete recipient ID, status, and file parts: %+v"
- errStDeletePartStatus = "failed to delete part status multi state vector: %+v"
-
- // SentTransfer.save
- errMarshalSentTransfer = "failed to marshal: %+v"
-)
-
-// SentTransfer contains information and progress data for sending or sent file
-// transfer.
-type SentTransfer struct {
- // Tracks cyphers for each part
- cypherManager *cypher.Manager
-
- // The ID of the transfer
- tid *ftCrypto.TransferID
-
- // User given name to file
- fileName string
-
- // ID of the recipient of the file transfer
- recipient *id.ID
-
- // The size of the entire file
- fileSize uint32
-
- // The number of file parts in the file
- numParts uint16
-
- // Indicates the status of the transfer
- status TransferStatus
-
- // List of all file parts in order to send
- parts [][]byte
-
- // Stores the status of each part in a bitstream format
- partStatus *utility.StateVector
-
- mux sync.RWMutex
- kv *versioned.KV
-}
-
-// newSentTransfer generates a new SentTransfer with the specified transfer key,
-// transfer ID, and parts.
-func newSentTransfer(recipient *id.ID, key *ftCrypto.TransferKey,
- tid *ftCrypto.TransferID, fileName string, fileSize uint32, parts [][]byte,
- numFps uint16, kv *versioned.KV) (*SentTransfer, error) {
- kv = kv.Prefix(makeSentTransferPrefix(tid))
-
- // Create new cypher manager
- cypherManager, err := cypher.NewManager(key, numFps, kv)
- if err != nil {
- return nil, errors.Errorf(errStNewCypherManager, err)
- }
-
- // Create new state vector for storing statuses of arrived parts
- partStatus, err := utility.NewStateVector(
- kv, sentTransferStatusKey, uint32(len(parts)))
- if err != nil {
- return nil, errors.Errorf(errStNewPartStatusVector, err)
- }
-
- st := &SentTransfer{
- cypherManager: cypherManager,
- tid: tid,
- fileName: fileName,
- recipient: recipient,
- fileSize: fileSize,
- numParts: uint16(len(parts)),
- status: Running,
- parts: parts,
- partStatus: partStatus,
- kv: kv,
- }
-
- return st, st.save()
-}
-
-// GetUnsentParts builds a list of all unsent parts, each in a Part object.
-func (st *SentTransfer) GetUnsentParts() []Part {
- unusedPartNumbers := st.partStatus.GetUnusedKeyNums()
- partList := make([]Part, len(unusedPartNumbers))
-
- for i, partNum := range unusedPartNumbers {
- partList[i] = Part{
- transfer: st,
- cypherManager: st.cypherManager,
- partNum: uint16(partNum),
- }
- }
-
- return partList
-}
-
-// getPartData returns the part data from the given part number.
-func (st *SentTransfer) getPartData(partNum uint16) []byte {
- if int(partNum) > len(st.parts)-1 {
- jww.FATAL.Panicf(errNoPartNum, partNum, st.tid, st.fileName)
- }
-
- return st.parts[partNum]
-}
-
-// markArrived marks the status of the given part numbers as arrived. When the
-// last part is marked arrived, the transfer is marked as completed.
-func (st *SentTransfer) markArrived(partNum uint16) {
- st.mux.Lock()
- defer st.mux.Unlock()
-
- st.partStatus.Use(uint32(partNum))
-
- // Mark transfer completed if all parts arrived
- if st.partStatus.GetNumUsed() == uint32(st.numParts) {
- st.status = Completed
- }
-}
-
-// markTransferFailed sets the transfer as failed. Only call this if no more
-// retries are available.
-func (st *SentTransfer) markTransferFailed() {
- st.mux.Lock()
- defer st.mux.Unlock()
- st.status = Failed
-}
-
-// Status returns the status of the transfer.
-func (st *SentTransfer) Status() TransferStatus {
- st.mux.RLock()
- defer st.mux.RUnlock()
- return st.status
-}
-
-// TransferID returns the transfer's ID.
-func (st *SentTransfer) TransferID() *ftCrypto.TransferID {
- return st.tid
-}
-
-// FileName returns the transfer's file name.
-func (st *SentTransfer) FileName() string {
- return st.fileName
-}
-
-// Recipient returns the transfer's recipient ID.
-func (st *SentTransfer) Recipient() *id.ID {
- return st.recipient
-}
-
-// FileSize returns the size of the entire file transfer.
-func (st *SentTransfer) FileSize() uint32 {
- return st.fileSize
-}
-
-// NumParts returns the total number of file parts in the transfer.
-func (st *SentTransfer) NumParts() uint16 {
- return st.numParts
-}
-
-// NumArrived returns the number of parts that have arrived.
-func (st *SentTransfer) NumArrived() uint16 {
- return uint16(st.partStatus.GetNumUsed())
-}
-
-// CopyPartStatusVector returns a copy of the part status vector that can be
-// used to look up the current status of parts. Note that the statuses are from
-// when this function is called and not realtime.
-func (st *SentTransfer) CopyPartStatusVector() *utility.StateVector {
- return st.partStatus.DeepCopy()
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Storage Functions //
-////////////////////////////////////////////////////////////////////////////////
-
-// loadSentTransfer loads the SentTransfer with the given transfer ID from
-// storage.
-func loadSentTransfer(tid *ftCrypto.TransferID, kv *versioned.KV) (
- *SentTransfer, error) {
- kv = kv.Prefix(makeSentTransferPrefix(tid))
-
- // Load cypher manager
- cypherManager, err := cypher.LoadManager(kv)
- if err != nil {
- return nil, errors.Errorf(errStLoadCypherManager, err)
- }
-
- // Load fileName, recipient ID, status, and file parts
- obj, err := kv.Get(sentTransferStoreKey, sentTransferStoreVersion)
- if err != nil {
- return nil, errors.Errorf(errStLoadFields, err)
- }
-
- fileName, recipient, status, parts, err := unmarshalSentTransfer(obj.Data)
- if err != nil {
- return nil, errors.Errorf(errStUnmarshalFields, err)
- }
-
- // Load state vector for storing statuses of arrived parts
- partStatus, err := utility.LoadStateVector(kv, sentTransferStatusKey)
- if err != nil {
- return nil, errors.Errorf(errStLoadPartStatusVector, err)
- }
-
- st := &SentTransfer{
- cypherManager: cypherManager,
- tid: tid,
- fileName: fileName,
- recipient: recipient,
- fileSize: calcFileSize(parts),
- numParts: uint16(len(parts)),
- status: status,
- parts: parts,
- partStatus: partStatus,
- kv: kv,
- }
-
- return st, nil
-}
-
-// calcFileSize calculates the size of the entire file from a list of parts. All
-// parts, except the last, are assumed to have the same length.
-func calcFileSize(parts [][]byte) uint32 {
- lastPartSize := len(parts[len(parts)-1])
- otherPartsSize := len(parts[0]) * (len(parts) - 1)
- return uint32(lastPartSize + otherPartsSize)
-}
-
-// Delete deletes all data in the SentTransfer from storage.
-func (st *SentTransfer) Delete() error {
- st.mux.Lock()
- defer st.mux.Unlock()
-
- // Delete cypher manager
- err := st.cypherManager.Delete()
- if err != nil {
- return errors.Errorf(errStDeleteCypherManager, err)
- }
-
- // Delete recipient ID, status, and file parts
- err = st.kv.Delete(sentTransferStoreKey, sentTransferStoreVersion)
- if err != nil {
- return errors.Errorf(errStDeleteSentTransfer, err)
- }
-
- // Delete part status multi state vector
- err = st.partStatus.Delete()
- if err != nil {
- return errors.Errorf(errStDeletePartStatus, err)
- }
-
- return nil
-}
-
-// save stores all fields in SentTransfer that do not have their own storage
-// (recipient ID, status, and file parts) to storage.
-func (st *SentTransfer) save() error {
- data, err := st.marshal()
- if err != nil {
- return errors.Errorf(errMarshalSentTransfer, err)
- }
-
- obj := &versioned.Object{
- Version: sentTransferStoreVersion,
- Timestamp: netTime.Now(),
- Data: data,
- }
-
- return st.kv.Set(sentTransferStoreKey, sentTransferStoreVersion, obj)
-}
-
-// sentTransferDisk structure is used to marshal and unmarshal SentTransfer
-// fields to/from storage.
-type sentTransferDisk struct {
- FileName string
- Recipient *id.ID
- Status TransferStatus
- Parts [][]byte
-}
-
-// marshal serialises the SentTransfer's fileName, recipient, status, and parts
-// list.
-func (st *SentTransfer) marshal() ([]byte, error) {
- disk := sentTransferDisk{
- FileName: st.fileName,
- Recipient: st.recipient,
- Status: st.status,
- Parts: st.parts,
- }
-
- return json.Marshal(disk)
-}
-
-// unmarshalSentTransfer deserializes the data into a fileName, recipient,
-// status, and parts list.
-func unmarshalSentTransfer(data []byte) (fileName string, recipient *id.ID,
- status TransferStatus, parts [][]byte, err error) {
- var disk sentTransferDisk
- err = json.Unmarshal(data, &disk)
- if err != nil {
- return "", nil, 0, nil, err
- }
-
- return disk.FileName, disk.Recipient, disk.Status, disk.Parts, nil
-}
-
-// makeSentTransferPrefix generates the unique prefix used on the key value
-// store to store sent transfers for the given transfer ID.
-func makeSentTransferPrefix(tid *ftCrypto.TransferID) string {
- return sentTransferStorePrefix +
- base64.StdEncoding.EncodeToString(tid.Bytes())
-}
diff --git a/fileTransfer2/store/sentTransfer_test.go b/fileTransfer2/store/sentTransfer_test.go
deleted file mode 100644
index 96d881c1f1f6ca15545be5f36c21779f1d730970..0000000000000000000000000000000000000000
--- a/fileTransfer2/store/sentTransfer_test.go
+++ /dev/null
@@ -1,496 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package store
-
-import (
- "bytes"
- "fmt"
- "gitlab.com/elixxir/client/fileTransfer2/store/cypher"
- "gitlab.com/elixxir/client/fileTransfer2/store/fileMessage"
- "gitlab.com/elixxir/client/storage/utility"
- "gitlab.com/elixxir/client/storage/versioned"
- ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
- "gitlab.com/elixxir/ekv"
- "gitlab.com/elixxir/primitives/format"
- "gitlab.com/xx_network/crypto/csprng"
- "gitlab.com/xx_network/primitives/id"
- "reflect"
- "strconv"
- "testing"
-)
-
-// Tests that newSentTransfer returns a new SentTransfer with the expected
-// values.
-func Test_newSentTransfer(t *testing.T) {
- kv := versioned.NewKV(ekv.MakeMemstore())
- key, _ := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
- tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
- numFps := uint16(24)
- parts := [][]byte{[]byte("hello"), []byte("hello"), []byte("hello")}
- stKv := kv.Prefix(makeSentTransferPrefix(&tid))
-
- cypherManager, err := cypher.NewManager(&key, numFps, stKv)
- if err != nil {
- t.Errorf("Failed to make new cypher manager: %+v", err)
- }
- partStatus, err := utility.NewStateVector(
- stKv, sentTransferStatusKey, uint32(len(parts)))
- if err != nil {
- t.Errorf("Failed to make new state vector: %+v", err)
- }
-
- expected := &SentTransfer{
- cypherManager: cypherManager,
- tid: &tid,
- fileName: "file",
- recipient: id.NewIdFromString("user", id.User, t),
- fileSize: calcFileSize(parts),
- numParts: uint16(len(parts)),
- status: Running,
- parts: parts,
- partStatus: partStatus,
- kv: stKv,
- }
-
- st, err := newSentTransfer(expected.recipient, &key, &tid,
- expected.fileName, expected.fileSize, parts, numFps, kv)
- if err != nil {
- t.Errorf("newSentTransfer returned an error: %+v", err)
- }
-
- if !reflect.DeepEqual(expected, st) {
- t.Errorf("New SentTransfer does not match expected."+
- "\nexpected: %+v\nreceived: %+v", expected, st)
- }
-}
-
-// Tests that SentTransfer.GetUnsentParts returns the correct number of unsent
-// parts
-func TestSentTransfer_GetUnsentParts(t *testing.T) {
- numParts := uint16(10)
- st, _, _, _, _ := newTestSentTransfer(numParts, t)
-
- // Check that all parts are returned after initialisation
- unsentParts := st.GetUnsentParts()
- if len(unsentParts) != int(numParts) {
- t.Errorf("Number of unsent parts does not match original number of "+
- "parts when none have been sent.\nexpected: %d\nreceived: %d",
- numParts, len(unsentParts))
- }
-
- // Ensure all parts have the proper part number
- for i, p := range unsentParts {
- if int(p.partNum) != i {
- t.Errorf("Part has incorrect part number."+
- "\nexpected: %d\nreceived: %d", i, p.partNum)
- }
- }
-
- // Use every other part
- for i := range unsentParts {
- if i%2 == 0 {
- unsentParts[i].MarkArrived()
- }
- }
-
- // Check that only have the number of parts is returned
- unsentParts = st.GetUnsentParts()
- if len(unsentParts) != int(numParts)/2 {
- t.Errorf("Number of unsent parts is not half original number after "+
- "half have been marked as arrived.\nexpected: %d\nreceived: %d",
- numParts/2, len(unsentParts))
- }
-
- // Ensure all parts have the proper part number
- for i, p := range unsentParts {
- if int(p.partNum) != i*2+1 {
- t.Errorf("Part has incorrect part number."+
- "\nexpected: %d\nreceived: %d", i*2+1, p.partNum)
- }
- }
-
- // Use the rest of the parts
- for i := range unsentParts {
- unsentParts[i].MarkArrived()
- }
-
- // Check that no sent parts are returned
- unsentParts = st.GetUnsentParts()
- if len(unsentParts) != 0 {
- t.Errorf("Number of unsent parts is not zero after all have been "+
- "marked as arrived.\nexpected: %d\nreceived: %d",
- 0, len(unsentParts))
- }
-}
-
-// Tests that SentTransfer.getPartData returns all the correct parts at their
-// expected indexes.
-func TestSentTransfer_getPartData(t *testing.T) {
- st, parts, _, _, _ := newTestSentTransfer(16, t)
-
- for i, part := range parts {
- partData := st.getPartData(uint16(i))
-
- if !bytes.Equal(part, partData) {
- t.Errorf("Incorrect part #%d.\nexpected: %q\nreceived: %q",
- i, part, partData)
- }
- }
-}
-
-// Tests that SentTransfer.getPartData panics when the part number is not within
-// the range of part numbers.
-func TestSentTransfer_getPartData_OutOfRangePanic(t *testing.T) {
- st, parts, _, _, _ := newTestSentTransfer(16, t)
-
- invalidPartNum := uint16(len(parts) + 1)
- expectedErr := fmt.Sprintf(errNoPartNum, invalidPartNum, st.tid, st.fileName)
-
- defer func() {
- r := recover()
- if r == nil || r != expectedErr {
- t.Errorf("getPartData did not return the expected error when the "+
- "part number %d is out of range.\nexpected: %s\nreceived: %+v",
- invalidPartNum, expectedErr, r)
- }
- }()
-
- _ = st.getPartData(invalidPartNum)
-}
-
-// Tests that after setting all parts as arrived via SentTransfer.markArrived,
-// there are no unsent parts left and the transfer is marked as Completed.
-func TestSentTransfer_markArrived(t *testing.T) {
- st, parts, _, _, _ := newTestSentTransfer(16, t)
-
- // Mark all parts as arrived
- for i := range parts {
- st.markArrived(uint16(i))
- }
-
- // Check that all parts are marked as arrived
- unsentParts := st.GetUnsentParts()
- if len(unsentParts) != 0 {
- t.Errorf("There are %d unsent parts.", len(unsentParts))
- }
-
- if st.status != Completed {
- t.Errorf("Status not correctly marked.\nexpected: %s\nreceived: %s",
- Completed, st.status)
- }
-}
-
-// Tests that SentTransfer.markTransferFailed changes the status of the transfer
-// to Failed.
-func TestSentTransfer_markTransferFailed(t *testing.T) {
- st, _, _, _, _ := newTestSentTransfer(16, t)
-
- st.markTransferFailed()
-
- if st.status != Failed {
- t.Errorf("Status not correctly marked.\nexpected: %s\nreceived: %s",
- Failed, st.status)
- }
-}
-
-// Tests that SentTransfer.Status returns the correct status of the transfer.
-func TestSentTransfer_Status(t *testing.T) {
- st, parts, _, _, _ := newTestSentTransfer(16, t)
-
- // Check that it is Running
- if st.Status() != Running {
- t.Errorf("Status returned incorrect status.\nexpected: %s\nreceived: %s",
- Running, st.Status())
- }
-
- // Mark all parts as arrived
- for i := range parts {
- st.markArrived(uint16(i))
- }
-
- // Check that it is Completed
- if st.Status() != Completed {
- t.Errorf("Status returned incorrect status.\nexpected: %s\nreceived: %s",
- Completed, st.Status())
- }
-
- // Mark transfer failed
- st.markTransferFailed()
-
- // Check that it is Failed
- if st.Status() != Failed {
- t.Errorf("Status returned incorrect status.\nexpected: %s\nreceived: %s",
- Failed, st.Status())
- }
-}
-
-// Tests that SentTransfer.TransferID returns the correct transfer ID.
-func TestSentTransfer_TransferID(t *testing.T) {
- st, _, _, _, _ := newTestSentTransfer(16, t)
-
- if st.TransferID() != st.tid {
- t.Errorf("Incorrect transfer ID.\nexpected: %s\nreceived: %s",
- st.tid, st.TransferID())
- }
-}
-
-// Tests that SentTransfer.FileName returns the correct file name.
-func TestSentTransfer_FileName(t *testing.T) {
- st, _, _, _, _ := newTestSentTransfer(16, t)
-
- if st.FileName() != st.fileName {
- t.Errorf("Incorrect transfer ID.\nexpected: %s\nreceived: %s",
- st.fileName, st.FileName())
- }
-}
-
-// Tests that SentTransfer.Recipient returns the correct recipient ID.
-func TestSentTransfer_Recipient(t *testing.T) {
- st, _, _, _, _ := newTestSentTransfer(16, t)
-
- if !st.Recipient().Cmp(st.recipient) {
- t.Errorf("Incorrect recipient ID.\nexpected: %s\nreceived: %s",
- st.recipient, st.Recipient())
- }
-}
-
-// Tests that SentTransfer.FileSize returns the correct file size.
-func TestSentTransfer_FileSize(t *testing.T) {
- st, parts, _, _, _ := newTestSentTransfer(16, t)
- fileSize := calcFileSize(parts)
-
- if st.FileSize() != fileSize {
- t.Errorf("Incorrect file size.\nexpected: %d\nreceived: %d",
- fileSize, st.FileSize())
- }
-}
-
-// Tests that SentTransfer.NumParts returns the correct number of parts.
-func TestSentTransfer_NumParts(t *testing.T) {
- numParts := uint16(16)
- st, _, _, _, _ := newTestSentTransfer(numParts, t)
-
- if st.NumParts() != numParts {
- t.Errorf("Incorrect number of parts.\nexpected: %d\nreceived: %d",
- numParts, st.NumParts())
- }
-}
-
-// Tests that SentTransfer.NumArrived returns the correct number of arrived
-// parts.
-func TestSentTransfer_NumArrived(t *testing.T) {
- st, parts, _, _, _ := newTestSentTransfer(16, t)
-
- if st.NumArrived() != 0 {
- t.Errorf("Incorrect number of arrived parts."+
- "\nexpected: %d\nreceived: %d", 0, st.NumArrived())
- }
-
- // Mark all parts as arrived
- for i := range parts {
- st.markArrived(uint16(i))
- }
-
- if uint32(st.NumArrived()) != st.partStatus.GetNumKeys() {
- t.Errorf("Incorrect number of arrived parts."+
- "\nexpected: %d\nreceived: %d",
- uint32(st.NumArrived()), st.partStatus.GetNumKeys())
- }
-}
-
-// Tests that the state vector returned by SentTransfer.CopyPartStatusVector
-// has the same values as the original but is a copy.
-func TestSentTransfer_CopyPartStatusVector(t *testing.T) {
- st, _, _, _, _ := newTestSentTransfer(16, t)
-
- // Check that the vectors have the same unused parts
- partStatus := st.CopyPartStatusVector()
- if !reflect.DeepEqual(
- partStatus.GetUnusedKeyNums(), st.partStatus.GetUnusedKeyNums()) {
- t.Errorf("Copied part status does not match original."+
- "\nexpected: %v\nreceived: %v",
- st.partStatus.GetUnusedKeyNums(), partStatus.GetUnusedKeyNums())
- }
-
- // Modify the state
- st.markArrived(5)
-
- // Check that the copied state is different
- if reflect.DeepEqual(
- partStatus.GetUnusedKeyNums(), st.partStatus.GetUnusedKeyNums()) {
- t.Errorf("Old copied part status matches new status."+
- "\nexpected: %v\nreceived: %v",
- st.partStatus.GetUnusedKeyNums(), partStatus.GetUnusedKeyNums())
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Storage Functions //
-////////////////////////////////////////////////////////////////////////////////
-
-// Tests that a SentTransfer loaded via loadSentTransfer matches the original.
-func Test_loadSentTransfer(t *testing.T) {
- st, _, _, _, kv := newTestSentTransfer(64, t)
-
- loadedSt, err := loadSentTransfer(st.tid, kv)
- if err != nil {
- t.Errorf("Failed to load SentTransfer: %+v", err)
- }
-
- if !reflect.DeepEqual(st, loadedSt) {
- t.Errorf("Loaded SentTransfer does not match original."+
- "\nexpected: %+v\nreceived: %+v", st, loadedSt)
- }
-}
-
-// Tests that SentTransfer.Delete deletes the storage backend of the
-// SentTransfer and that it cannot be loaded again.
-func TestSentTransfer_Delete(t *testing.T) {
- st, _, _, _, kv := newTestSentTransfer(64, t)
-
- err := st.Delete()
- if err != nil {
- t.Errorf("Delete returned an error: %+v", err)
- }
-
- _, err = loadSentTransfer(st.tid, kv)
- if err == nil {
- t.Errorf("Loaded sent transfer that was deleted.")
- }
-}
-
-// Tests that the fields saved by SentTransfer.save can be loaded from storage.
-func TestSentTransfer_save(t *testing.T) {
- st, _, _, _, _ := newTestSentTransfer(64, t)
-
- err := st.save()
- if err != nil {
- t.Errorf("save returned an error: %+v", err)
- }
-
- _, err = st.kv.Get(sentTransferStoreKey, sentTransferStoreVersion)
- if err != nil {
- t.Errorf("Failed to load saved SentTransfer: %+v", err)
- }
-}
-
-// Tests that a SentTransfer marshalled via SentTransfer.marshal and
-// unmarshalled via unmarshalSentTransfer matches the original.
-func TestSentTransfer_marshal_unmarshalSentTransfer(t *testing.T) {
- st := &SentTransfer{
- fileName: "transferName",
- recipient: id.NewIdFromString("user", id.User, t),
- status: Failed,
- parts: [][]byte{[]byte("Message"), []byte("Part")},
- }
-
- data, err := st.marshal()
- if err != nil {
- t.Errorf("marshal returned an error: %+v", err)
- }
-
- fileName, recipient, status, parts, err := unmarshalSentTransfer(data)
- if err != nil {
- t.Errorf("Failed to unmarshal SentTransfer: %+v", err)
- }
-
- if st.fileName != fileName {
- t.Errorf("Incorrect file name.\nexpected: %q\nreceived: %q",
- st.fileName, fileName)
- }
-
- if !st.recipient.Cmp(recipient) {
- t.Errorf("Incorrect recipient.\nexpected: %s\nreceived: %s",
- st.recipient, recipient)
- }
-
- if status != status {
- t.Errorf("Incorrect status.\nexpected: %s\nreceived: %s",
- status, status)
- }
-
- if !reflect.DeepEqual(st.parts, parts) {
- t.Errorf("Incorrect parts.\nexpected: %q\nreceived: %q",
- st.parts, parts)
- }
-}
-
-// Consistency test of makeSentTransferPrefix.
-func Test_makeSentTransferPrefix_Consistency(t *testing.T) {
- expectedPrefixes := []string{
- "SentFileTransferStore/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
- "SentFileTransferStore/AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
- "SentFileTransferStore/AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
- "SentFileTransferStore/AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
- "SentFileTransferStore/BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
- "SentFileTransferStore/BQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
- "SentFileTransferStore/BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
- "SentFileTransferStore/BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
- "SentFileTransferStore/CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
- "SentFileTransferStore/CQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
- }
-
- for i, expected := range expectedPrefixes {
- tid := ftCrypto.TransferID{byte(i)}
- prefix := makeSentTransferPrefix(&tid)
-
- if expected != prefix {
- t.Errorf("Prefix #%d does not match expected."+
- "\nexpected: %q\nreceived: %q", i, expected, prefix)
- }
- }
-}
-
-const numPrimeBytes = 512
-
-// newTestSentTransfer creates a new SentTransfer for testing.
-func newTestSentTransfer(numParts uint16, t *testing.T) (st *SentTransfer,
- parts [][]byte, key *ftCrypto.TransferKey, numFps uint16, kv *versioned.KV) {
- kv = versioned.NewKV(ekv.MakeMemstore())
- recipient := id.NewIdFromString("recipient", id.User, t)
- keyTmp, _ := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
- tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
- numFps = 2 * numParts
- fileName := "helloFile"
- parts, file := generateTestParts(numParts)
-
- st, err := newSentTransfer(
- recipient, &keyTmp, &tid, fileName, uint32(len(file)), parts, numFps, kv)
- if err != nil {
- t.Errorf("Failed to make new SentTransfer: %+v", err)
- }
-
- return st, parts, &keyTmp, numFps, kv
-}
-
-// generateTestParts generates a list of file parts of the correct size to be
-// encrypted/decrypted.
-func generateTestParts(numParts uint16) (parts [][]byte, file []byte) {
- // Calculate part size
- partSize := fileMessage.NewPartMessage(
- format.NewMessage(numPrimeBytes).ContentsSize()).GetPartSize()
-
- // Create list of parts and fill
- parts = make([][]byte, numParts)
- var buff bytes.Buffer
- buff.Grow(int(numParts) * partSize)
- for i := range parts {
- parts[i] = make([]byte, partSize)
- copy(parts[i], "Hello "+strconv.Itoa(i))
- buff.Write(parts[i])
- }
-
- return parts, buff.Bytes()
-}
diff --git a/fileTransfer2/store/sent_test.go b/fileTransfer2/store/sent_test.go
deleted file mode 100644
index e1b7556b6c62d59f17df86c6a8b74632094b7636..0000000000000000000000000000000000000000
--- a/fileTransfer2/store/sent_test.go
+++ /dev/null
@@ -1,283 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package store
-
-import (
- "bytes"
- "fmt"
- "gitlab.com/elixxir/client/storage/versioned"
- ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
- "gitlab.com/elixxir/ekv"
- "gitlab.com/xx_network/crypto/csprng"
- "gitlab.com/xx_network/primitives/id"
- "reflect"
- "sort"
- "strconv"
- "testing"
-)
-
-// Tests that NewOrLoadSent returns a new Sent when none exist in storage and
-// that the list of unsent parts is nil.
-func TestNewOrLoadSent_New(t *testing.T) {
- kv := versioned.NewKV(ekv.MakeMemstore())
- expected := &Sent{
- transfers: make(map[ftCrypto.TransferID]*SentTransfer),
- kv: kv.Prefix(sentTransfersStorePrefix),
- }
-
- s, unsentParts, err := NewOrLoadSent(kv)
- if err != nil {
- t.Errorf("NewOrLoadSent returned an error: %+v", err)
- }
-
- if !reflect.DeepEqual(expected, s) {
- t.Errorf("New Sent does not match expected."+
- "\nexpected: %+v\nreceived: %+v", expected, s)
- }
-
- if unsentParts != nil {
- t.Errorf("List of parts should be nil when not loading: %+v",
- unsentParts)
- }
-}
-
-// Tests that NewOrLoadSent returns a loaded Sent when one exist in storage and
-// that the list of unsent parts is correct.
-func TestNewOrLoadSent_Load(t *testing.T) {
- kv := versioned.NewKV(ekv.MakeMemstore())
- s, _, err := NewOrLoadSent(kv)
- if err != nil {
- t.Errorf("Failed to make new Sent: %+v", err)
- }
- var expectedUnsentParts []Part
-
- // Create and add transfers to map and save
- for i := 0; i < 10; i++ {
- key, _ := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
- tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
- parts, file := generateTestParts(uint16(10 + i))
- st, err2 := s.AddTransfer(
- id.NewIdFromString("recipient"+strconv.Itoa(i), id.User, t),
- &key, &tid, "file"+strconv.Itoa(i), uint32(len(file)), parts,
- uint16(2*(10+i)))
- if err2 != nil {
- t.Errorf("Failed to add transfer #%d: %+v", i, err2)
- }
- expectedUnsentParts = append(expectedUnsentParts, st.GetUnsentParts()...)
- }
- if err = s.save(); err != nil {
- t.Errorf("Failed to make save filled Sent: %+v", err)
- }
-
- // Load Sent
- loadedSent, unsentParts, err := NewOrLoadSent(kv)
- if err != nil {
- t.Errorf("Failed to load Sent: %+v", err)
- }
-
- // Check that the loaded Sent matches original
- if !reflect.DeepEqual(s, loadedSent) {
- t.Errorf("Loaded Sent does not match original."+
- "\nexpected: %v\nreceived: %v", s, loadedSent)
- }
-
- sort.Slice(unsentParts, func(i, j int) bool {
- switch bytes.Compare(unsentParts[i].TransferID()[:],
- unsentParts[j].TransferID()[:]) {
- case -1:
- return true
- case 1:
- return false
- default:
- return unsentParts[i].partNum < unsentParts[j].partNum
- }
- })
-
- sort.Slice(expectedUnsentParts, func(i, j int) bool {
- switch bytes.Compare(expectedUnsentParts[i].TransferID()[:],
- expectedUnsentParts[j].TransferID()[:]) {
- case -1:
- return true
- case 1:
- return false
- default:
- return expectedUnsentParts[i].partNum < expectedUnsentParts[j].partNum
- }
- })
-
- // Check that the unsent parts matches expected
- if !reflect.DeepEqual(expectedUnsentParts, unsentParts) {
- t.Errorf("Incorrect unsent parts.\nexpected: %v\nreceived: %v",
- expectedUnsentParts, unsentParts)
- }
-}
-
-// Tests that Sent.AddTransfer makes a new transfer and adds it to the list.
-func TestSent_AddTransfer(t *testing.T) {
- kv := versioned.NewKV(ekv.MakeMemstore())
- s, _, _ := NewOrLoadSent(kv)
-
- key, _ := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
- tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
- parts, file := generateTestParts(10)
-
- st, err := s.AddTransfer(id.NewIdFromString("recipient", id.User, t),
- &key, &tid, "file", uint32(len(file)), parts, 20)
- if err != nil {
- t.Errorf("Failed to add new transfer: %+v", err)
- }
-
- // Check that the transfer was added
- if _, exists := s.transfers[*st.tid]; !exists {
- t.Errorf("No transfer with ID %s exists.", st.tid)
- }
-}
-
-// Tests that Sent.AddTransfer returns an error when adding a transfer ID that
-// already exists.
-func TestSent_AddTransfer_TransferAlreadyExists(t *testing.T) {
- tid := ftCrypto.TransferID{0}
- s := &Sent{
- transfers: map[ftCrypto.TransferID]*SentTransfer{tid: nil},
- }
-
- expectedErr := fmt.Sprintf(errAddExistingSentTransfer, tid)
- _, err := s.AddTransfer(nil, nil, &tid, "", 0, nil, 0)
- if err == nil || err.Error() != expectedErr {
- t.Errorf("Received unexpected error when adding transfer that already "+
- "exists.\nexpected: %s\nreceived: %+v", expectedErr, err)
- }
-}
-
-// Tests that Sent.GetTransfer returns the expected transfer.
-func TestSent_GetTransfer(t *testing.T) {
- kv := versioned.NewKV(ekv.MakeMemstore())
- s, _, _ := NewOrLoadSent(kv)
-
- key, _ := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
- tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
- parts, file := generateTestParts(10)
-
- st, err := s.AddTransfer(id.NewIdFromString("recipient", id.User, t),
- &key, &tid, "file", uint32(len(file)), parts, 20)
- if err != nil {
- t.Errorf("Failed to add new transfer: %+v", err)
- }
-
- // Check that the transfer was added
- receivedSt, exists := s.GetTransfer(st.tid)
- if !exists {
- t.Errorf("No transfer with ID %s exists.", st.tid)
- }
-
- if !reflect.DeepEqual(st, receivedSt) {
- t.Errorf("Received SentTransfer does not match expected."+
- "\nexpected: %+v\nreceived: %+v", st, receivedSt)
- }
-}
-
-// Tests that Sent.RemoveTransfer removes the transfer from the list.
-func TestSent_RemoveTransfer(t *testing.T) {
- kv := versioned.NewKV(ekv.MakeMemstore())
- s, _, _ := NewOrLoadSent(kv)
-
- key, _ := ftCrypto.NewTransferKey(csprng.NewSystemRNG())
- tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
- parts, file := generateTestParts(10)
-
- st, err := s.AddTransfer(id.NewIdFromString("recipient", id.User, t),
- &key, &tid, "file", uint32(len(file)), parts, 20)
- if err != nil {
- t.Errorf("Failed to add new transfer: %+v", err)
- }
-
- // Delete the transfer
- err = s.RemoveTransfer(st.tid)
- if err != nil {
- t.Errorf("RemoveTransfer returned an error: %+v", err)
- }
-
- // Check that the transfer was deleted
- _, exists := s.GetTransfer(st.tid)
- if exists {
- t.Errorf("Transfer %s exists.", st.tid)
- }
-
- // Remove transfer that was already removed
- err = s.RemoveTransfer(st.tid)
- if err != nil {
- t.Errorf("RemoveTransfer returned an error: %+v", err)
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Storage Functions //
-////////////////////////////////////////////////////////////////////////////////
-
-// Tests that Sent.save saves the transfer ID list to storage by trying to load
-// it after a save.
-func TestSent_save(t *testing.T) {
- kv := versioned.NewKV(ekv.MakeMemstore())
- s, _, _ := NewOrLoadSent(kv)
- s.transfers = map[ftCrypto.TransferID]*SentTransfer{
- ftCrypto.TransferID{0}: nil, ftCrypto.TransferID{1}: nil,
- ftCrypto.TransferID{2}: nil, ftCrypto.TransferID{3}: nil,
- }
-
- err := s.save()
- if err != nil {
- t.Errorf("Failed to save transfer ID list: %+v", err)
- }
-
- _, err = s.kv.Get(sentTransfersStoreKey, sentTransfersStoreVersion)
- if err != nil {
- t.Errorf("Failed to load transfer ID list: %+v", err)
- }
-}
-
-// Tests that the transfer IDs keys in the map marshalled by
-// marshalSentTransfersMap and unmarshalled by unmarshalTransferIdList match the
-// original.
-func Test_marshalSentTransfersMap_unmarshalTransferIdList(t *testing.T) {
- // Build map of transfer IDs
- transfers := make(map[ftCrypto.TransferID]*SentTransfer, 10)
- for i := 0; i < 10; i++ {
- tid, _ := ftCrypto.NewTransferID(csprng.NewSystemRNG())
- transfers[tid] = nil
- }
-
- data, err := marshalSentTransfersMap(transfers)
- if err != nil {
- t.Errorf("marshalSentTransfersMap returned an error: %+v", err)
- }
-
- tidList, err := unmarshalTransferIdList(data)
- if err != nil {
- t.Errorf("unmarshalSentTransfer returned an error: %+v", err)
- }
-
- for _, tid := range tidList {
- if _, exists := transfers[tid]; exists {
- delete(transfers, tid)
- } else {
- t.Errorf("Transfer %s does not exist in list.", tid)
- }
- }
-
- if len(transfers) != 0 {
- t.Errorf("%d transfers not in unmarshalled list: %v",
- len(transfers), transfers)
- }
-}
diff --git a/fileTransfer2/store/transferStatus.go b/fileTransfer2/store/transferStatus.go
deleted file mode 100644
index e8674b711f36a62f064548f1f9928598cf44aa8d..0000000000000000000000000000000000000000
--- a/fileTransfer2/store/transferStatus.go
+++ /dev/null
@@ -1,64 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package store
-
-import (
- "encoding/binary"
- "strconv"
-)
-
-// TransferStatus indicates the state of the transfer.
-type TransferStatus int
-
-const (
- // Running indicates that the transfer is in the processes of sending
- Running TransferStatus = iota
-
- // Completed indicates that all file parts have been sent and arrived
- Completed
-
- // Failed indicates that the transfer has run out of sending retries
- Failed
-)
-
-const invalidTransferStatusStringErr = "INVALID TransferStatus: "
-
-// String prints the string representation of the TransferStatus. This function
-// satisfies the fmt.Stringer interface.
-func (ts TransferStatus) String() string {
- switch ts {
- case Running:
- return "running"
- case Completed:
- return "completed"
- case Failed:
- return "failed"
- default:
- return invalidTransferStatusStringErr + strconv.Itoa(int(ts))
- }
-}
-
-// Marshal returns the byte representation of the TransferStatus.
-func (ts TransferStatus) Marshal() []byte {
- b := make([]byte, 8)
- binary.LittleEndian.PutUint64(b, uint64(ts))
- return b
-}
-
-// UnmarshalTransferStatus unmarshalls the 8-byte byte slice into a
-// TransferStatus.
-func UnmarshalTransferStatus(b []byte) TransferStatus {
- return TransferStatus(binary.LittleEndian.Uint64(b))
-}
diff --git a/fileTransfer2/store/transferStatus_test.go b/fileTransfer2/store/transferStatus_test.go
deleted file mode 100644
index f87c666c5b5dbec24db6149314b7f339e88ce13c..0000000000000000000000000000000000000000
--- a/fileTransfer2/store/transferStatus_test.go
+++ /dev/null
@@ -1,54 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package store
-
-import (
- "strconv"
- "testing"
-)
-
-// Tests that TransferStatus.String returns the expected string for each value
-// of TransferStatus.
-func Test_TransferStatus_String(t *testing.T) {
- testValues := map[TransferStatus]string{
- Running: "running",
- Completed: "completed",
- Failed: "failed",
- 100: invalidTransferStatusStringErr + strconv.Itoa(100),
- }
-
- for status, expected := range testValues {
- if expected != status.String() {
- t.Errorf("TransferStatus string incorrect."+
- "\nexpected: %s\nreceived: %s", expected, status.String())
- }
- }
-}
-
-// Tests that a marshalled and unmarshalled TransferStatus matches the original.
-func Test_TransferStatus_Marshal_UnmarshalTransferStatus(t *testing.T) {
- testValues := []TransferStatus{Running, Completed, Failed}
-
- for _, status := range testValues {
- marshalledStatus := status.Marshal()
-
- newStatus := UnmarshalTransferStatus(marshalledStatus)
-
- if status != newStatus {
- t.Errorf("Marshalled and unmarshalled TransferStatus does not "+
- "match original.\nexpected: %s\nreceived: %s", status, newStatus)
- }
- }
-}
diff --git a/fileTransfer2/utils_test.go b/fileTransfer2/utils_test.go
deleted file mode 100644
index 7f2de0eb05a1bf0086cd2050c7794e02386033c7..0000000000000000000000000000000000000000
--- a/fileTransfer2/utils_test.go
+++ /dev/null
@@ -1,212 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC //
-// //
-// Use of this source code is governed by a license that can be found in the //
-// LICENSE file //
-////////////////////////////////////////////////////////////////////////////////
-
-package fileTransfer2
-
-import (
- "bytes"
- "encoding/binary"
- jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/client/cmix"
- "gitlab.com/elixxir/client/cmix/identity/receptionID"
- "gitlab.com/elixxir/client/cmix/message"
- "gitlab.com/elixxir/client/cmix/rounds"
- "gitlab.com/elixxir/client/storage/versioned"
- "gitlab.com/elixxir/crypto/cyclic"
- "gitlab.com/elixxir/crypto/fastRNG"
- "gitlab.com/elixxir/ekv"
- "gitlab.com/elixxir/primitives/format"
- "gitlab.com/xx_network/crypto/csprng"
- "gitlab.com/xx_network/crypto/large"
- "gitlab.com/xx_network/primitives/id"
- "gitlab.com/xx_network/primitives/id/ephemeral"
- "io"
- "math/rand"
- "sync"
- "testing"
- "time"
-)
-
-// newFile generates a file with random data of size numParts * partSize.
-// Returns the full file and the file parts. If the partSize allows, each part
-// starts with a "|<[PART_001]" and ends with a ">|".
-func newFile(numParts uint16, partSize int, prng io.Reader, t *testing.T) (
- []byte, [][]byte) {
- const (
- prefix = "|<[PART_%3d]"
- suffix = ">|"
- )
- // Create file buffer of the expected size
- fileBuff := bytes.NewBuffer(make([]byte, 0, int(numParts)*partSize))
- partList := make([][]byte, numParts)
-
- // Create new rand.Rand with the seed generated from the io.Reader
- b := make([]byte, 8)
- _, err := prng.Read(b)
- if err != nil {
- t.Errorf("Failed to generate random seed: %+v", err)
- }
- seed := binary.LittleEndian.Uint64(b)
- randPrng := rand.New(rand.NewSource(int64(seed)))
-
- for partNum := range partList {
- s := RandStringBytes(partSize, randPrng)
- if len(s) >= (len(prefix) + len(suffix)) {
- partList[partNum] = []byte(
- prefix + s[:len(s)-(len(prefix)+len(suffix))] + suffix)
- } else {
- partList[partNum] = []byte(s)
- }
-
- fileBuff.Write(partList[partNum])
- }
-
- return fileBuff.Bytes(), partList
-}
-
-const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
-
-// RandStringBytes generates a random string of length n consisting of the
-// characters in letterBytes.
-func RandStringBytes(n int, prng *rand.Rand) string {
- b := make([]byte, n)
- for i := range b {
- b[i] = letterBytes[prng.Intn(len(letterBytes))]
- }
- return string(b)
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Mock cMix //
-////////////////////////////////////////////////////////////////////////////////
-
-type mockCmixHandler struct {
- sync.Mutex
- processorMap map[format.Fingerprint]message.Processor
-}
-
-func newMockCmixHandler() *mockCmixHandler {
- return &mockCmixHandler{
- processorMap: make(map[format.Fingerprint]message.Processor),
- }
-}
-
-type mockCmix struct {
- myID *id.ID
- numPrimeBytes int
- health bool
- handler *mockCmixHandler
- healthCBs map[uint64]func(b bool)
- healthIndex uint64
- round id.Round
- sync.Mutex
-}
-
-func newMockCmix(
- myID *id.ID, handler *mockCmixHandler, storage *mockStorage) *mockCmix {
- return &mockCmix{
- myID: myID,
- numPrimeBytes: storage.GetCmixGroup().GetP().ByteLen(),
- health: true,
- handler: handler,
- healthCBs: make(map[uint64]func(b bool)),
- round: 0,
- healthIndex: 0,
- }
-}
-
-func (m *mockCmix) GetMaxMessageLength() int {
- msg := format.NewMessage(m.numPrimeBytes)
- return msg.ContentsSize()
-}
-
-func (m *mockCmix) SendMany(messages []cmix.TargetedCmixMessage,
- _ cmix.CMIXParams) (id.Round, []ephemeral.Id, error) {
- m.handler.Lock()
- defer m.handler.Unlock()
- round := m.round
- m.round++
- for _, targetedMsg := range messages {
- msg := format.NewMessage(m.numPrimeBytes)
- msg.SetContents(targetedMsg.Payload)
- msg.SetMac(targetedMsg.Mac)
- msg.SetKeyFP(targetedMsg.Fingerprint)
- m.handler.processorMap[targetedMsg.Fingerprint].Process(msg,
- receptionID.EphemeralIdentity{Source: targetedMsg.Recipient},
- rounds.Round{ID: round})
- }
- return round, []ephemeral.Id{}, nil
-}
-
-func (m *mockCmix) AddFingerprint(_ *id.ID, fp format.Fingerprint, mp message.Processor) error {
- m.handler.Lock()
- defer m.handler.Unlock()
- m.handler.processorMap[fp] = mp
- return nil
-}
-
-func (m *mockCmix) DeleteFingerprint(_ *id.ID, fp format.Fingerprint) {
- m.handler.Lock()
- defer m.handler.Unlock()
- delete(m.handler.processorMap, fp)
-}
-
-func (m *mockCmix) CheckInProgressMessages() {}
-
-func (m *mockCmix) IsHealthy() bool {
- return m.health
-}
-
-func (m *mockCmix) WasHealthy() bool { return true }
-
-func (m *mockCmix) AddHealthCallback(f func(bool)) uint64 {
- m.Lock()
- defer m.Unlock()
- m.healthIndex++
- m.healthCBs[m.healthIndex] = f
- go f(true)
- return m.healthIndex
-}
-
-func (m *mockCmix) RemoveHealthCallback(healthID uint64) {
- m.Lock()
- defer m.Unlock()
- if _, exists := m.healthCBs[healthID]; !exists {
- jww.FATAL.Panicf("No health callback with ID %d exists.", healthID)
- }
- delete(m.healthCBs, healthID)
-}
-
-func (m *mockCmix) GetRoundResults(_ time.Duration,
- roundCallback cmix.RoundEventCallback, rids ...id.Round) error {
- go roundCallback(true, false, map[id.Round]cmix.RoundResult{rids[0]: {}})
- return nil
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Mock Storage Session //
-////////////////////////////////////////////////////////////////////////////////
-
-type mockStorage struct {
- kv *versioned.KV
- cmixGroup *cyclic.Group
-}
-
-func newMockStorage() *mockStorage {
- b := make([]byte, 768)
- rng := fastRNG.NewStreamGenerator(1000, 10, csprng.NewSystemRNG).GetStream()
- _, _ = rng.Read(b)
- rng.Close()
-
- return &mockStorage{
- kv: versioned.NewKV(ekv.MakeMemstore()),
- cmixGroup: cyclic.NewGroup(large.NewIntFromBytes(b), large.NewInt(2)),
- }
-}
-
-func (m *mockStorage) GetKV() *versioned.KV { return m.kv }
-func (m *mockStorage) GetCmixGroup() *cyclic.Group { return m.cmixGroup }