Skip to content
GitLab
Commit 110085e7 authored by Bassam Tabbara's avatar Bassam Tabbara Committed by GitHub
Browse files

Merge pull request #151 from bassamtabbara/docs-and-licensing 

initial docs and licensing
parents 3ab8958e b3c4f18c
Hide whitespace changes
Inline Side-by-side
Showing
with 557 additions and 338 deletions
+557 -338
CONTRIBUTING.md 0 → 100644
+ 62
- 0
View file @ 110085e7
## How to Contribute
The Rook project in under [Apache 2.0 license](LICENSE). We accept contributions via
GitHub pull requests. This document outlines some of the conventions related to
development workflow, commit message formatting, contact points and other
resources to make it easier to get your contribution accepted.
## Certificate of Origin
By contributing to this project you agree to the Developer Certificate of
Origin (DCO). This document was created by the Linux Kernel community and is a
simple statement that you, as a contributor, have the legal right to make the
contribution. See the [DCO](DCO) file for details.
## Getting Started
- Fork the repository on GitHub
- Read the [README](README.md) for build and test instructions
- Play with the project, submit bugs, submit patches!
## Contribution Flow
This is a rough outline of what a contributor's workflow looks like:
- Create a branch from where you want to base your work (usually master).
- Make your changes and arrange them in readable commits.
- Make sure your commit messages are in the proper format (see below).
- Push your changes to the branch in your fork of the repository.
- Make sure all tests pass, and add any new tests as appropriate.
- Submit a pull request to the original repository.
## Coding Style
Rook projects are written in golang and follows the style guidelines dictated by
the go fmt as well as go vet tools.
## Commit Messages
We follow a rough convention for commit messages that is designed to answer two
questions: what changed and why. The subject line should feature the what and
the body of the commit should describe the why.
```
cephmgr: update MON to use rocksdb
this enables us to remove leveldb from the codebase.
```
The format can be described more formally as follows:
```
<subsystem>: <what changed>
<BLANK LINE>
<why this change was made>
<BLANK LINE>
<footer>
```
The first line is the subject and should be no longer than 70 characters, the
second line is always blank, and other lines should be wrapped at 80 characters.
This allows the message to be easier to read on GitHub as well as in various
git tools.
DCO 0 → 100644
+ 36
- 0
View file @ 110085e7
Developer Certificate of Origin
Version 1.1
Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
660 York Street, Suite 102,
San Francisco, CA 94110 USA
Everyone is permitted to copy and distribute verbatim copies of this
license document, but changing it is not allowed.
Developer's Certificate of Origin 1.1
By making a contribution to this project, I certify that:
(a) The contribution was created in whole or in part by me and I
have the right to submit it under the open source license
indicated in the file; or
(b) The contribution is based upon previous work that, to the best
of my knowledge, is covered under an appropriate open source
license and I have the right under that license to submit that
work with modifications, whether created in whole or in part
by me, under the same open source license (unless I am
permitted to submit under a different license), as indicated
in the file; or
(c) The contribution was provided directly to me by some other
person who certified (a), (b) or (c) and I have not modified
it.
(d) I understand and agree that this project and the contribution
are public and that a record of the contribution (including all
personal information I submit with it, including my sign-off) is
maintained indefinitely and may be redistributed consistent with
this project or the open source license(s) involved.
Documentation/build.md deleted 100644 → 0
+ 0
- 103
View file @ 3ab8958e
# Building
Rook is golang binary that uses cgo to interface with embedded ceph. The ceph
project is a submodule of rook and is built from the top level Makefile.
## Static binary
This is the easiest option and produced static binaries for rookd and tools. These
binaries can easily be used inside minimal or scratch containers, or run on minimal
linux distributions like CoreOS.
```
make STATIC=1
```
## Dyanmic binary
If you dont want to distribute a static binary, a dynamically linked binary is
supported. The approach we take is to link most of the glibc binaries dynamically
and the rest of the libraries continue to be linked statically. Ceph has a lot
of dependencies and we take this approach to simplify the distribution.
```
make STATIC=0
```
## Hardened binary (PIE)
You can build a Position Independent executable as follows:
```
make STATIC=0 PIE=1
```
## Switching Allocators
Using a different memory allocator can impact the overall performance of the system.
Three allocators are currently supported: jemalloc, tcmalloc and libc. To specify
an allocator during the build run the following:
```
make ALLOCATOR=jemalloc
```
## Debug Builds
To build a binary with debug symbols run the following:
```
make DEBUG=1
```
Note the binary will be significantly larger in size.
## Verbose Builds
To turn on verbose build output run the following
```
make V=1
```
## Parallel Builds
You can speed up the build significantly by passing the -j flag to make as follows:
```
make -j4
```
## Enabling ccache
C++ code can take time to compile. CCache can increase the speed of compilation. To
enable make sure you have ccache installed:
```
apt-get install ccache
```
to run with ccache enable run the following:
```
export CCACHE_DIR=~/.ccache
make
```
to check ccache stats run:
```
ccache -s
```
to clear the stats run:
```
ccache -z
```
to clear the cache run:
```
ccache -C
```
Documentation/dev-setup.md deleted 100644 → 0
+ 0
- 19
View file @ 3ab8958e
# Recommended Environment
* Ubuntu 16.04+ (parallels VM is good for mac)
# Start up steps
```bash
cd $GOPATH/src/github.com/rook
git clone https://github.com/rook/rook.git
cd rook
git submodule update --init --recursive
sudo apt-get install cmake python-sphinx libudev-dev libaio-dev libblkid-dev libldap2-dev xfslibs-dev libleveldb-dev libexpat1-dev cython libfcgi-dev libatomic-ops-dev libsnappy-dev libgoogle-perftools-dev libjemalloc-dev libkeyutils-dev libcurl4-openssl-dev libcrypto++-dev libssl-dev libboost-dev libboost-thread-dev libboost-system-dev libboost-regex-dev libboost-random-dev libboost-program-options-dev libboost-date-time-dev libboost-iostreams-dev python3-all-dev cython3 yasm mercurial
make -j3 build
./bin/rookd
```
# Unit tests
Due to the static compilation flags the tests also require the same to find ceph even though we don't activate any of the ceph cgo code in the tests.
```
make test
```
Documentation/getting-started.md deleted 100644 → 0
+ 0
- 125
View file @ 3ab8958e
# Starting your first castle cluster
### 1) Create a new cluster
The easiest way to create a new cluster is through the global discovery service:
```
curl -w "\n" 'https://discovery.castle.io/new?min-size=3&dns=true'
https://discovery.castle.io/6a28e078895c5ec737174db2419bb2f3
```
This will return a URL that acts as the logical "address" of the cluster, and enables
clients to easily find the cluster.
The minimum size parameter can be used to prevent the cluster from starting up until
the specified number of nodes join.
The DNS parameter will cause the discovery service to publish a DNS name for
the new cluster like:
```
6a28e078895c5ec737174db2419bb2f3.castle.io
```
You can create custom CNAME entries in your own DNS servers that point to these entries,
for example:
```
mycluster.acme.com
```
### 2) Add nodes to the cluster
You now need to start castle on nodes which will automatically find each other through
the discovery service and form a cluster. You can run the castle nodes using a number
of different approaches.
#### Running manually
Download castle from http://github.com/rook/rook/releases
```
castle \
--discovery-url=https://discovery.castle.io/6a28e078895c5ec737174db2419bb2f3 \
--devices sda,sdb,sdc \
--public-network 10.0.10.0/24 \
--private-network 10.0.20.0/24
```
* TODO: other options: CPU affinity and limiting to support hyper-converged
* TODO: crush location for example, data-center=red,rack=17,server=blue23
* TODO: choices for selecting the kind of hardware? NVMe etc.? or can we autodetect?
#### Running from systemd
TODO:
#### Running from docker
TODO: privileged container with /dev mapped?
#### Running from rkt
TODO: rkt fly
#### Running on CoreOS
TODO: show how castle can be configured from cloud-init and started
#### Running from Ubuntu
#### Running from Centos
At this point the storage cluster is up and running.
### 3) Using castle
Now that the cluster is up and running, you can communicate with it using castletctl. First
you need export an environment variable for the cluster url:
```
export ROOKD_DISCOVERY_URL=https://discovery.castle.io/6a28e078895c5ec737174db2419bb2f3
```
or if you're using DNS:
```
export ROOKD_DISCOVERY_DNS=mycluster.acme.com
```
Let's list the nodes that are part of the cluster:
```
castle node ls
```
the output shows the nodes that are part of the cluster
```
ADDRESS STATE CLUSTER SIZE LOCATION UPDATED
10.0.10.1:70000 OK mycluster.acme.com 30 TiB dc=A,rack=17,server=a 1 sec ago
10.0.10.2:70000 OK mycluster.acme.com 40 TiB dc=A,rack=18,server=b 1 sec ago
10.0.10.3:70000 OK mycluster.acme.com 50 TiB dc=A,rack=19,server=c 1 sec ago
```
### 4) Creating a volume
To create a volume run the following:
```
castle volume create myvolume 100GiB
```
This creates a volume that can be used as a block device from client nodes.
### 5) Mount the volume on a client node
To mount the volume run the following on the client node:
```
export ROOKD_DISCOVERY_DNS=mycluster.acme.com
sudo castleblk rbd myvolume
```
You can mount the volume through NBD or RBD.
Documentation/launch.md deleted 100644 → 0
+ 0
- 21
View file @ 3ab8958e
# Running castled
## Setup
1. Copy your `castled` binary to one or more CoreOS machines
2. Generate a discovery token
```
token_size=3
discovery_token=$(curl -w "\n" "https://discovery.etcd.io/new?size=$token_size" 2>/dev/null)
echo $discovery_token
```
## Run castle
Start the castled process on each machine. Don't forget to set or replace your $discovery_token variable
`./castled --discovery-url=$discovery_token --private-ipv4=${COREOS_PRIVATE_IPV4} --devices=sdb,sdc,sdd --force-format=true`
## Cleanup
Between runs you may want to clean everything up and start over. In this case, run the script on each of the nodes in the cluster:
`clean-castled.sh`
This script is found in the `scripts` folder of this repo.
Documentation/media/cluster.png 0 → 100644
+ 0
- 0
View file @ 110085e7
Documentation/media/cluster.png

94.2 KB

Documentation/media/logo.png 0 → 100644
+ 0
- 0
View file @ 110085e7
Documentation/media/logo.png

5.35 KB

Documentation/publishing.md deleted 100644 → 0
+ 0
- 69
View file @ 3ab8958e
# Publishing rookd
The below steps will walk you through how to build on your Mac host, using the cross compilation build container, and publishing artifacts to both dockerhub and quay.io.
### Install Docker for Mac
Building on the mac for all platforms is done via a container, so you'll need Docker installed locally. You can install from the **Beta channel** on this page:
https://docs.docker.com/docker-for-mac/
#### Docker settings
* 4 CPU, 4 GB RAM
* exclude VM from time machine backups
* File sharing tab: only /Users
#### Verify Docker works
Ensure that you `unset DOCKER_HOST` in case you still have it pointing at your old registry machine. Verify that Docker for Mac is working locally by running this on your Mac and getting a successful response:
```
docker info
```
### Make commands in the build container
All make commands are run in the container with the build/run script. Essentially, anything you want to do with make in the container can be done simply be prefacing your make command with `build/run`:
```
build/run make -j4 build
```
### Cleaning
To clean up the build container and it's persistent volumes, you can run the below command. You shouldn't have to do this often unless something is broken or stale with your build container:
```
build/clean
```
To clean up the build *inside* the build container, instead of destroy the container itself, run:
```
build/run make clean
```
Of course, if you've run `build/clean`, there's no reason to run this command since you've already blown away the entire container.
### Building
#### Temporary vendor workaround
As described in #93 (https://github.com/rook/rook/93), before building in the container, you should run vendoring **locally** on your Mac, then the vendored sources will get synced to build container later on.
```
make vendor
```
Now you can build in the container normally, like so:
```
build/run make -j4
```
This will build just the binaries for the host OS/arch and copy them to the applicable subfolder of ./bin.
### Releasing
Releasing creates not only the binaries but also all the packages and containers for deploying to rookd users. Note that it does **not** publish or upload these release packages off your box. It is all local. After the following command is run, all useful packages will be found in ./release.
```
build/run make -j4 release
```
### Publishing
The publishing step will upload all release packages to central deployment services, such as dockerhub and quay.io. There are a few pre-requisites for publishing:
1. A release must be tagged in github. You can do this by going to https://github.com/rook/rook/releases/new, and creating a new release. The release should have a sensible semantic version, and it should be for the commit of your choosing (probably HEAD on master).
2. dockerhub and quay.io credentials. These will be imported to the container via ~/.docker/config.json, so all you have to do to get them there is `docker login` and `docker login quay.io`
3. A github personal access token. You can get a token from https://github.com/settings/tokens (or reuse one that you're already using on your mac. I went into Keychain Access -> passwords, and searched for github. The "application password" entry is probably the one you want)
After all prerequisites are met, you can publish with the following command (substituting in the correct values):
```
build/run make -j4 GITHUB_TOKEN=${your_github_token} VERSION=${release_semantic_version} publish
```
This will take awhile to upload the many flavors of containers to their destinations, so be patient and don't interrupt it.
Once the containers are uploaded, you will need to manually move the "latest" tag in quay.io to the image you just uploaded. This can be done at:
https://quay.io/repository/rook/rookd?tab=tags
LICENSE
+ 201
- 0
View file @ 110085e7
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "{}"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright 2016 The Rook Authors. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Makefile
+ 14
- 0
View file @ 110085e7
# Copyright 2016 The Rook Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# set the shell to bash in case some environments use sh
.PHONY: all
all: build
......
README.md
+ 132
- 1
View file @ 110085e7
# Rook - Open Software Defined Storage
![logo](Documentation/media/logo.png?raw=true "Rook")
[![Circle CI](https://circleci.com/gh/rook/rook.svg?style=svg&circle-token=2b2ee7eb7f621e612a76f861353e141a8caaf8dd)](https://circleci.com/gh/rook/rook)
[![Build Status](https://jenkins.rook.io/job/ci-build-stateful/badge/icon)](https://jenkins.rook.io/job/ci-build-stateful/)
## Open, Cloud Native, and Universal Distributed Storage
- [What is Rook?](#what-is-rook)
- [Status](#status)
- [Quickstart](#quickstart)
- [Building](#building)
- [Design](#design)
- [Contributing](#contributing)
- [Contact](#contact)
- [Licensing](#licensing)
## What is Rook?
Rook is a distributed storage system designed for cloud native applications. It
exposes file, block, and object storage on top of shared resource pools. Rook has minimal
dependencies and can be deployed in dedicated storage clusters or converged clusters. It's
self-managing, self-protecting, self-healing, and is designed to just work without teams of
engineers managing it. It scales from a single node, to multi-PB clusters spread geographically.
It's based on the Ceph project with over 10 years of production deployments in some of the
largest storage clusters in the world.
## Status
Rook is in **alpha** state. We're just getting started. Not all planned feature are complete. The API
and other user-facing objects are subject to change. Backward-compability is not supported for this
release. See our [Roadmap](https://github.com/rook/rook/wiki/Roadmap) and [Issues](https://github.com/rook/rook/issues).
Please help us by [Contributing](CONTRIBUTING.md) to the project.
## Quickstart
Here's the quickest way to get going with Rook.
### Linux
On a modern Linux host run the following:
1. Download the latest binaries
```bash
$ wget https://github.com/rook/rook/releases/download/v0.0.6/rook-v0.0.6-linux-amd64.tar.gz
$ tar xvf rook-v0.0.6-linux-amd64.tar.gz
```
2. Start a one node Rook cluster
```bash
$ ./rookd --data-dir /tmp/rook-test
```
3. Now in a different shell (in the same path) create a new volume image (10MB)
```bash
$ ./rook block create --name test --size 10485760
```
4. Mount the block volume and format it
```bash
sudo ./rook block mount --name test --path /tmp/rook-volume
```
5. Write and read a file
```bash
echo "Hello Rook!" > /tmp/rook-volume/hello
cat /tmp/rook-volume/hello
```
### Kubernetes
To run a Kubernetes cluster with Rook for persistent storage go [here](https://github.com/rook/coreos-kubernetes)
### CoreOS
Rook is also easy to run on CoreOS either directly on the host or via rkt.
```
cd demo/vagrant
vagrant up
```
## Building
See [Building](https://github.com/rook/rook/wiki/Design) in the wiki for more details.
## Design
A rook cluster is made up of one or more nodes each running the Rook daemon `rookd`. Containers and Pods can
mount block devices and filesystems exposed by the cluster, or can use S3/Swift API for object storage. There is
also a REST API exposed by `rookd` as well as a command line tool called `rook`.
![Overview](Documentation/media/cluster.png)
The Rook daemon `rookd` is a single binary that is self-contained and has all that is needed to bootstrap, scale
and manage a storage cluster. `rookd` is typically compiled into a single static binary (just like most golang
binaries) or a dynamic binary that takes a dependency on mostly libc. It can run in minimal containers, alongside a
hypervisor, or directly on the host on most Linux distributions.
`rookd` uses an embedded version of Ceph for storing all data -- there are no changes to the data path. An embedded version
of Ceph was created specifically for Rook scenarios and has been pushed upstream. Rook does attempt to maintain full fidelity
with Ceph, for example, most of the Ceph concepts like OSDs, MONs, placement groups, etc. are hidden. Instead Rook creates
a much simplified UX for admins that is in terms of physical resources, pools, volumes, filesystems, and buckets.
`rookd` embeds Etcd within the cluster store configuration, and coordinates cluster-wide management operations. `rookd` will automatically
bootstrap Etcd, manage it, and scale it as the cluster grows. Its also possible to use an external Etcd instead of the embedded one
if needed.
Rook and etcd are implementd in golang. Ceph is implemented in C++ where the data is highly optimized. We believe
the combination offers the best of both worlds.
See [Design](https://github.com/rook/rook/wiki/Design) wiki for more details.
## Contributing
We welcome contributions. See [Contributing](CONTRIBUTING.md) to get started.
## Report a Bug
For filing bugs, suggesting improvements, or requesting new features, help us out by opening an [issue](https://github.com/rook/rook/issues).
## Contact
Please use the following to reach members of the community:
- Email: [rook-dev](https://groups.google.com/forum/#!forum/rook-dev)
- Gitter: [rook-dev](https://gitter.im/rook/rook-dev)
## Licensing
Rook is under the Apache 2.0 license.
build/clean
+ 14
- 0
View file @ 110085e7
#!/bin/bash -e
# Copyright 2016 The Rook Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
scriptdir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
source "${scriptdir}/common.sh"
......
build/common.sh
+ 14
- 0
View file @ 110085e7
#!/bin/bash -e
# Copyright 2016 The Rook Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
source_repo=github.com/rook/rook
container_version=$(cat ${scriptdir}/cross-image/version)
......
build/cross-image/Dockerfile
+ 14
- 0
View file @ 110085e7
# Copyright 2016 The Rook Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
FROM ubuntu:xenial
MAINTAINER Bassam Tabbara <bassam.tabbara@quantum.com>
......
build/cross-image/Makefile
+ 14
- 0
View file @ 110085e7
# Copyright 2016 The Rook Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
.PHONY: all build publish
all: build
......
build/cross-image/entrypoint.sh
+ 14
- 0
View file @ 110085e7
#!/bin/bash -e
# Copyright 2016 The Rook Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
ARGS="$@"
if [ $# -eq 0 ]; then
ARGS=/bin/bash
......
build/cross-image/rsyncd.sh
+ 14
- 0
View file @ 110085e7
#!/bin/bash -e
# Copyright 2016 The Rook Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
VOLUME=${VOLUME:-/volume}
ALLOW=${ALLOW:-192.168.0.0/16 172.16.0.0/12 10.0.0.0/8}
OWNER=${OWNER:-nobody}
......
build/makelib/cephd.mk
+ 14
- 0
View file @ 110085e7
# Copyright 2016 The Rook Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ====================================================================================
# Makefile helper functions for building embedded ceph
......
build/makelib/cross.mk
+ 14
- 0
View file @ 110085e7
# Copyright 2016 The Rook Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ====================================================================================
# Makefile helper functions for cross compiling
#
......
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

免费DevSecOps平台，让您的项目体验完整的DevSecOps流程，让项目更安全